initial commit

This commit is contained in:
dahyeon committed 2026-04-11 11:27:53 -07:00
commit 6215e0fb7d
31158 files changed
+4069656

No files matched your search

@@ -0,0 +1,21 @@
MIT License
Copyright (c) 2024 Adam Shaw
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
@@ -0,0 +1,214 @@
# temporal-polyfill
A lightweight polyfill for [Temporal](https://tc39.es/proposal-temporal/docs/), successor to the JavaScript `Date` object
Only 20 kB, [spec compliant](#spec-compliance)
## Table of Contents
- [Installation](#installation)
- [Comparison with `@js-temporal/polyfill`](#comparison-with-js-temporalpolyfill)
- [Spec Compliance](#spec-compliance)
- [Browser Support](#browser-support)
- [BigInt Considerations](#bigint-considerations)
- [Tree-shakable API](#tree-shakable-api) (coming soon)
## Installation
```
npm install temporal-polyfill
```
Import as an ES module without side effects:
```js
import { Temporal } from 'temporal-polyfill'
console.log(Temporal.Now.zonedDateTimeISO().toString())
```
Or, import globally:
```js
import 'temporal-polyfill/global'
console.log(Temporal.Now.zonedDateTimeISO().toString())
```
Use a `<script>` tags with a CDN link:
```html
<script src='https://cdn.jsdelivr.net/npm/temporal-polyfill@0.3.0/global.min.js'></script>
<script>
console.log(Temporal.Now.zonedDateTimeISO().toString())
</script>
```
## Comparison with `@js-temporal/polyfill`
<table>
<tr>
<td>Package</td>
<td>
<code>temporal-polyfill</code>
</td>
<td>
<code>@js-temporal/polyfill</code>
</td>
</tr>
<tr>
<td>Repo</td>
<td>
<a href='https://github.com/fullcalendar/temporal-polyfill'>
fullcalendar/temporal-polyfill
</a>
</td>
<td>
<a href='https://github.com/js-temporal/temporal-polyfill'>
js-temporal/temporal-polyfill
</a>
</td>
</tr>
<tr>
<td>Creators</td>
<td><a href='https://fullcalendar.io/'>FullCalendar</a> lead dev <a href='https://github.com/arshaw'>arshaw</a></td>
<td>Champions of the <a href='https://github.com/tc39/proposal-temporal'>Temporal proposal</a></td>
</tr>
<tr>
<td>Minified+gzip size</td>
<td><a href='https://bundlephobia.com/package/temporal-polyfill'>19.8 KB<a></td>
<td><a href='https://bundlephobia.com/package/@js-temporal/polyfill'>51.9 KB</a> (+162%)</td>
</tr>
<tr>
<td>Spec date</td>
<td>
Mar 2025
</td>
<td>
Mar 2025
</td>
</tr>
<tr>
<td>BigInt approach</td>
<td>Internally avoids BigInt operations altogether</td>
<td>Internally relies on <a href='https://github.com/GoogleChromeLabs/jsbi'>JSBI</a></td>
</tr>
<tr>
<td>Global usage in ESM</td>
<td>
<code>import 'temporal-polyfill/global'</code>
</td>
<td>Not currently possible</td>
</tr>
</table>
## Spec Compliance
All calendar systems (ex: `chinese`, `persian`) and all time zones are supported.
Compliance with the latest version of the Temporal spec is near-perfect [with just 4 intentional deviations](https://github.com/fullcalendar/temporal-polyfill/blob/main/packages/temporal-polyfill/scripts/test262-config/expected-failures.txt).
## Browser Support
<table>
<tr>
<td colspan='6'>
<strong>Minimum required browsers for ISO/gregory calendars:</strong>
</td>
</tr>
<tr>
<!-- Computed from Libraries+Syntax in worksheet below -->
<td>Chrome 60<br />(Jul 2017)</td>
<td>Firefox 55<br />(Aug 2017)</td>
<td>Safari 11.1<br />(Mar 2018)</td>
<td>Safari iOS 11.3<br />(Mar 2018)</td>
<td>Edge 79<br />(Jan 2020)</td>
<td>Node.js 14<br />(Apr 2020)</td>
</tr>
<tr>
<td colspan='6'>
<br />
<strong>If you transpile, you can support older browsers down to:</strong>
</td>
</tr>
<tr>
<!-- Computed from Libraries in worksheet below -->
<td>Chrome 57<br />(Mar 2017)</td>
<td>Firefox 52<br />(Mar 2017)</td>
<td>Safari 10<br />(Sep 2016)</td>
<td>Safari iOS 10<br />(Sep 2016)</td>
<td>Edge 15<br />(Apr 2017)</td>
<td>Node.js 14<br />(Apr 2020)</td>
</tr>
<tr>
<td colspan='6'>
<br />
<strong>For non-ISO/gregory calendars, requirements are higher:</strong>
</td>
</tr>
<tr>
<!-- https://caniuse.com/mdn-javascript_builtins_intl_datetimeformat_datetimeformat_options_parameter_options_calendar_parameter -->
<td>Chrome 80<br />(Feb 2020)</td>
<td>Firefox 76<br />(May 2020)</td>
<td>Safari 14.1<br />(Apr 2021)</td>
<td>Safari iOS 14.5<br />(Apr 2021)</td>
<td>Edge 80<br />(Feb 2020)</td>
<td>Node.js 14<br />(Apr 2020)</td>
</tr>
</table>
<!--
## Browser Support Worksheet
Use caniuse's star feature to find intersection of features.
Libraries:
- [Intl.DateTimeFormat IANA time zone names](https://caniuse.com/mdn-javascript_builtins_intl_datetimeformat_datetimeformat_options_parameter_options_timezone_parameter_iana_time_zones)
- [Number.isInteger](https://caniuse.com/mdn-javascript_builtins_number_isinteger)
- [Number.isSafeInteger] (https://caniuse.com/mdn-javascript_builtins_number_issafeinteger)
- [String::padStart](https://caniuse.com/mdn-javascript_builtins_string_padstart)
- [WeakMap](https://caniuse.com/mdn-javascript_builtins_weakmap)
Syntax:
- [Classes](https://caniuse.com/es6-class)
- [Exponentiation](https://caniuse.com/mdn-javascript_operators_exponentiation)
- [Spread in array literals](https://caniuse.com/mdn-javascript_operators_spread_spread_in_arrays)
- [Spread in function calls](https://caniuse.com/mdn-javascript_operators_spread_spread_in_function_calls)
- [Spread in object literals](https://caniuse.com/mdn-javascript_operators_spread_spread_in_object_literals)
BigInt (https://caniuse.com/bigint):
- Chrome 67 (May 2018)
- Firefox 68 (Jul 2019)
- Safari 14 (Sep 2020)
- Safari iOS 14 (Sep 2020)
- Edge 79 (Jan 2020)
Node.js is always 14 because the test-runner doesn't work with lower
-->
## BigInt Considerations
This polyfill does NOT depend on [BigInt](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt) support. Internally, no operations leverage BigInt arithmetics. :thumbsup:
However, if you plan to use methods that accept/emit BigInts, your environment must support it. Alternatively, you can avoid using these methods altogether. [There's a cheatsheet](https://gist.github.com/arshaw/1ef4bf945d68654b86cef2dd8471c48f) to help you.
## Tree-shakable API
🚧 Coming Soon
For library authors and other devs who are hyper-concerned about bundle size, `temporal-polyfill` will be providing an alternate API designed for tree-shaking.
```js
import * as ZonedDateTime from 'temporal-polyfill/fns/zoneddatetime'
const zdt = ZonedDateTime.from({ year: 2024, month: 1, day: 1 })
const s = ZonedDateTime.toString(zdt) // not how you normally call a method!
```
@@ -0,0 +1,599 @@
"use strict";
function createSlotClass(branding, construct, getters, methods, staticMethods, formatFunc) {
function Class(...args) {
if (!(this instanceof Class)) {
throw new TypeError(internal.invalidCallingContext);
}
{
const slots = construct(...args);
setSlots(this, slots), dbg(this, slots, formatFunc);
}
}
function bindMethod(method, methodName) {
return Object.defineProperties((function(...args) {
return method.call(this, getSpecificSlots(this), ...args);
}), internal.createNameDescriptors(methodName));
}
function getSpecificSlots(obj) {
const slots = getSlots(obj);
if (!slots || slots.branding !== branding) {
throw new TypeError(internal.invalidCallingContext);
}
return slots;
}
return Object.defineProperties(Class.prototype, {
...internal.createGetterDescriptors(internal.mapProps(bindMethod, getters)),
...internal.createPropDescriptors(internal.mapProps(bindMethod, methods)),
...internal.createStringTagDescriptors("Temporal." + branding)
}), Object.defineProperties(Class, {
...internal.createPropDescriptors(staticMethods),
...internal.createNameDescriptors(branding)
}), [ Class, slots => {
const instance = Object.create(Class.prototype);
return setSlots(instance, slots), dbg(instance, slots, formatFunc), instance;
}, getSpecificSlots ];
}
function rejectInvalidBag(bag) {
if (getSlots(bag) || void 0 !== bag.calendar || void 0 !== bag.timeZone) {
throw new TypeError(internal.invalidBag);
}
return bag;
}
function dbg(instance, slots, formatSlots) {
"dbg" === dbg.name && Object.defineProperty(instance, "_str_", {
value: formatSlots(slots),
writable: 0,
enumerable: 0,
configurable: 0
});
}
function getCalendarIdFromBag(bag) {
return extractCalendarIdFromBag(bag) || internal.isoCalendarId;
}
function extractCalendarIdFromBag(bag) {
const {calendar: calendarArg} = bag;
if (void 0 !== calendarArg) {
return refineCalendarArg(calendarArg);
}
}
function refineCalendarArg(arg) {
if (internal.isObjectLike(arg)) {
const {calendar: calendar} = getSlots(arg) || {};
if (!calendar) {
throw new TypeError(internal.invalidCalendar(arg));
}
return calendar;
}
return (arg => internal.resolveCalendarId(internal.parseCalendarId(internal.requireString(arg))))(arg);
}
function createCalendarGetters(methodNameMap) {
const methods = {};
for (const methodName in methodNameMap) {
methods[methodName] = slots => {
const {calendar: calendar} = slots;
return internal.createNativeStandardOps(calendar)[methodName](slots);
};
}
return methods;
}
function neverValueOf() {
throw new TypeError(internal.forbiddenValueOf);
}
function refineTimeZoneArg(arg) {
if (internal.isObjectLike(arg)) {
const {timeZone: timeZone} = getSlots(arg) || {};
if (!timeZone) {
throw new TypeError(internal.invalidTimeZone(arg));
}
return timeZone;
}
return (arg => internal.resolveTimeZoneId(internal.parseTimeZoneId(internal.requireString(arg))))(arg);
}
function toDurationSlots(arg) {
if (internal.isObjectLike(arg)) {
const slots = getSlots(arg);
return slots && slots.branding === internal.DurationBranding ? slots : internal.refineDurationBag(arg);
}
return internal.parseDuration(arg);
}
function refinePublicRelativeTo(relativeTo) {
if (void 0 !== relativeTo) {
if (internal.isObjectLike(relativeTo)) {
const slots = getSlots(relativeTo) || {};
switch (slots.branding) {
case internal.ZonedDateTimeBranding:
case internal.PlainDateBranding:
return slots;
case internal.PlainDateTimeBranding:
return internal.createPlainDateSlots(slots);
}
const calendarId = getCalendarIdFromBag(relativeTo);
return {
...internal.refineMaybeZonedDateTimeBag(refineTimeZoneArg, internal.queryNativeTimeZone, internal.createNativeStandardOps(calendarId), relativeTo),
calendar: calendarId
};
}
return internal.parseRelativeToSlots(relativeTo);
}
}
function toPlainTimeSlots(arg, options) {
if (internal.isObjectLike(arg)) {
const slots = getSlots(arg) || {};
switch (slots.branding) {
case internal.PlainTimeBranding:
return internal.refineOverflowOptions(options), slots;
case internal.PlainDateTimeBranding:
return internal.refineOverflowOptions(options), internal.createPlainTimeSlots(slots);
case internal.ZonedDateTimeBranding:
return internal.refineOverflowOptions(options), internal.zonedDateTimeToPlainTime(internal.queryNativeTimeZone, slots);
}
return internal.refinePlainTimeBag(arg, options);
}
const timeSlots = internal.parsePlainTime(arg);
return internal.refineOverflowOptions(options), timeSlots;
}
function optionalToPlainTimeFields(timeArg) {
return void 0 === timeArg ? void 0 : toPlainTimeSlots(timeArg);
}
function toPlainDateTimeSlots(arg, options) {
if (internal.isObjectLike(arg)) {
const slots = getSlots(arg) || {};
switch (slots.branding) {
case internal.PlainDateTimeBranding:
return internal.refineOverflowOptions(options), slots;
case internal.PlainDateBranding:
return internal.refineOverflowOptions(options), internal.createPlainDateTimeSlots({
...slots,
...internal.isoTimeFieldDefaults
});
case internal.ZonedDateTimeBranding:
return internal.refineOverflowOptions(options), internal.zonedDateTimeToPlainDateTime(internal.queryNativeTimeZone, slots);
}
return internal.refinePlainDateTimeBag(internal.createNativeStandardOps(getCalendarIdFromBag(arg)), arg, options);
}
const res = internal.parsePlainDateTime(arg);
return internal.refineOverflowOptions(options), res;
}
function toPlainMonthDaySlots(arg, options) {
if (internal.isObjectLike(arg)) {
const slots = getSlots(arg);
if (slots && slots.branding === internal.PlainMonthDayBranding) {
return internal.refineOverflowOptions(options), slots;
}
const calendarIdMaybe = extractCalendarIdFromBag(arg), calendarId = calendarIdMaybe || internal.isoCalendarId;
return internal.refinePlainMonthDayBag(internal.createNativeStandardOps(calendarId), !calendarIdMaybe, arg, options);
}
const res = internal.parsePlainMonthDay(internal.createNativeStandardOps, arg);
return internal.refineOverflowOptions(options), res;
}
function toPlainYearMonthSlots(arg, options) {
if (internal.isObjectLike(arg)) {
const slots = getSlots(arg);
return slots && slots.branding === internal.PlainYearMonthBranding ? (internal.refineOverflowOptions(options),
slots) : internal.refinePlainYearMonthBag(internal.createNativeStandardOps(getCalendarIdFromBag(arg)), arg, options);
}
const res = internal.parsePlainYearMonth(internal.createNativeStandardOps, arg);
return internal.refineOverflowOptions(options), res;
}
function toPlainDateSlots(arg, options) {
if (internal.isObjectLike(arg)) {
const slots = getSlots(arg) || {};
switch (slots.branding) {
case internal.PlainDateBranding:
return internal.refineOverflowOptions(options), slots;
case internal.PlainDateTimeBranding:
return internal.refineOverflowOptions(options), internal.createPlainDateSlots(slots);
case internal.ZonedDateTimeBranding:
return internal.refineOverflowOptions(options), internal.zonedDateTimeToPlainDate(internal.queryNativeTimeZone, slots);
}
return internal.refinePlainDateBag(internal.createNativeStandardOps(getCalendarIdFromBag(arg)), arg, options);
}
const res = internal.parsePlainDate(arg);
return internal.refineOverflowOptions(options), res;
}
function toZonedDateTimeSlots(arg, options) {
if (internal.isObjectLike(arg)) {
const slots = getSlots(arg);
if (slots && slots.branding === internal.ZonedDateTimeBranding) {
return internal.refineZonedFieldOptions(options), slots;
}
const calendarId = getCalendarIdFromBag(arg);
return internal.refineZonedDateTimeBag(refineTimeZoneArg, internal.queryNativeTimeZone, internal.createNativeStandardOps(calendarId), calendarId, arg, options);
}
return internal.parseZonedDateTime(arg, options);
}
function adaptDateMethods(methods) {
return internal.mapProps((method => slots => method(slotsToIso(slots))), methods);
}
function slotsToIso(slots) {
return internal.zonedEpochSlotsToIso(slots, internal.queryNativeTimeZone);
}
function toInstantSlots(arg) {
if (internal.isObjectLike(arg)) {
const slots = getSlots(arg);
if (slots) {
switch (slots.branding) {
case internal.InstantBranding:
return slots;
case internal.ZonedDateTimeBranding:
return internal.createInstantSlots(slots.epochNanoseconds);
}
}
}
return internal.parseInstant(arg);
}
function createFormatMethod(methodName) {
return Object.defineProperties((function(...formattables) {
const prepFormat = internalsMap.get(this), [format, ...rawFormattables] = prepFormat(methodName.includes("Range"), ...formattables);
return format[methodName](...rawFormattables);
}), internal.createNameDescriptors(methodName));
}
function createProxiedMethod(methodName) {
return Object.defineProperties((function(...args) {
return internalsMap.get(this).rawFormat[methodName](...args);
}), internal.createNameDescriptors(methodName));
}
function createFormatPrepperForBranding(branding) {
const config = classFormatConfigs[branding];
if (!config) {
throw new TypeError(internal.invalidFormatType(branding));
}
return internal.createFormatPrepper(config, internal.memoize(internal.createFormatForPrep), 1);
}
var internal = require("./internal.cjs");
const slotsMap = new WeakMap, getSlots = slotsMap.get.bind(slotsMap), setSlots = slotsMap.set.bind(slotsMap), yearMonthOnlyRefiners = {
era: internal.requireStringOrUndefined,
eraYear: internal.requireIntegerOrUndefined,
year: internal.requireInteger,
month: internal.requirePositiveInteger,
daysInMonth: internal.requirePositiveInteger,
daysInYear: internal.requirePositiveInteger,
inLeapYear: internal.requireBoolean,
monthsInYear: internal.requirePositiveInteger
}, monthOnlyRefiners = {
monthCode: internal.requireString
}, dayOnlyRefiners = {
day: internal.requirePositiveInteger
}, dateOnlyRefiners = {
dayOfWeek: internal.requirePositiveInteger,
dayOfYear: internal.requirePositiveInteger,
weekOfYear: internal.requirePositiveIntegerOrUndefined,
yearOfWeek: internal.requireIntegerOrUndefined,
daysInWeek: internal.requirePositiveInteger
}, dateGetters = createCalendarGetters({
...yearMonthOnlyRefiners,
...monthOnlyRefiners,
...dayOnlyRefiners,
...dateOnlyRefiners
}), yearMonthGetters = createCalendarGetters({
...yearMonthOnlyRefiners,
...monthOnlyRefiners
}), monthDayGetters = createCalendarGetters({
...monthOnlyRefiners,
...dayOnlyRefiners
}), calendarIdGetters = {
calendarId: slots => slots.calendar
}, durationGetters = internal.mapPropNames((propName => slots => slots[propName]), internal.durationFieldNamesAsc.concat("sign")), timeGetters = internal.mapPropNames(((_name, i) => slots => slots[internal.isoTimeFieldNamesAsc[i]]), internal.timeFieldNamesAsc), epochGetters = {
epochMilliseconds: internal.getEpochMilli,
epochNanoseconds: internal.getEpochNano
}, [Duration, createDuration, getDurationSlots] = createSlotClass(internal.DurationBranding, internal.constructDurationSlots, {
...durationGetters,
blank: internal.getDurationBlank
}, {
with: (slots, mod) => createDuration(internal.durationWithFields(slots, mod)),
negated: slots => createDuration(internal.negateDuration(slots)),
abs: slots => createDuration(internal.absDuration(slots)),
add: (slots, otherArg, options) => createDuration(internal.addDurations(refinePublicRelativeTo, internal.createNativeStandardOps, internal.queryNativeTimeZone, 0, slots, toDurationSlots(otherArg), options)),
subtract: (slots, otherArg, options) => createDuration(internal.addDurations(refinePublicRelativeTo, internal.createNativeStandardOps, internal.queryNativeTimeZone, 1, slots, toDurationSlots(otherArg), options)),
round: (slots, options) => createDuration(internal.roundDuration(refinePublicRelativeTo, internal.createNativeStandardOps, internal.queryNativeTimeZone, slots, options)),
total: (slots, options) => internal.totalDuration(refinePublicRelativeTo, internal.createNativeStandardOps, internal.queryNativeTimeZone, slots, options),
toLocaleString(slots, locales, options) {
return Intl.DurationFormat ? new Intl.DurationFormat(locales, options).format(this) : internal.formatDurationIso(slots);
},
toString: internal.formatDurationIso,
toJSON: slots => internal.formatDurationIso(slots),
valueOf: neverValueOf
}, {
from: arg => createDuration(toDurationSlots(arg)),
compare: (durationArg0, durationArg1, options) => internal.compareDurations(refinePublicRelativeTo, internal.createNativeStandardOps, internal.queryNativeTimeZone, toDurationSlots(durationArg0), toDurationSlots(durationArg1), options)
}, internal.formatDurationIso), classFormatConfigs = {
Instant: internal.instantConfig,
PlainDateTime: internal.dateTimeConfig,
PlainDate: internal.dateConfig,
PlainTime: internal.timeConfig,
PlainYearMonth: internal.yearMonthConfig,
PlainMonthDay: internal.monthDayConfig
}, prepInstantFormat = internal.createFormatPrepper(internal.instantConfig), prepZonedDateTimeFormat = internal.createFormatPrepper(internal.zonedConfig), prepPlainDateTimeFormat = internal.createFormatPrepper(internal.dateTimeConfig), prepPlainDateFormat = internal.createFormatPrepper(internal.dateConfig), prepPlainTimeFormat = internal.createFormatPrepper(internal.timeConfig), prepPlainYearMonthFormat = internal.createFormatPrepper(internal.yearMonthConfig), prepPlainMonthDayFormat = internal.createFormatPrepper(internal.monthDayConfig), [PlainTime, createPlainTime] = createSlotClass(internal.PlainTimeBranding, internal.constructPlainTimeSlots, timeGetters, {
with(_slots, mod, options) {
return createPlainTime(internal.plainTimeWithFields(this, rejectInvalidBag(mod), options));
},
add: (slots, durationArg) => createPlainTime(internal.movePlainTime(0, slots, toDurationSlots(durationArg))),
subtract: (slots, durationArg) => createPlainTime(internal.movePlainTime(1, slots, toDurationSlots(durationArg))),
until: (slots, otherArg, options) => createDuration(internal.diffPlainTimes(0, slots, toPlainTimeSlots(otherArg), options)),
since: (slots, otherArg, options) => createDuration(internal.diffPlainTimes(1, slots, toPlainTimeSlots(otherArg), options)),
round: (slots, options) => createPlainTime(internal.roundPlainTime(slots, options)),
equals: (slots, other) => internal.plainTimesEqual(slots, toPlainTimeSlots(other)),
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepPlainTimeFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: internal.formatPlainTimeIso,
toJSON: slots => internal.formatPlainTimeIso(slots),
valueOf: neverValueOf
}, {
from: (arg, options) => createPlainTime(toPlainTimeSlots(arg, options)),
compare: (arg0, arg1) => internal.compareIsoTimeFields(toPlainTimeSlots(arg0), toPlainTimeSlots(arg1))
}, internal.formatPlainTimeIso), [PlainDateTime, createPlainDateTime] = createSlotClass(internal.PlainDateTimeBranding, internal.bindArgs(internal.constructPlainDateTimeSlots, internal.refineCalendarId), {
...calendarIdGetters,
...dateGetters,
...timeGetters
}, {
with: (slots, mod, options) => createPlainDateTime(internal.plainDateTimeWithFields(internal.createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
withCalendar: (slots, calendarArg) => createPlainDateTime(internal.slotsWithCalendarId(slots, refineCalendarArg(calendarArg))),
withPlainTime: (slots, plainTimeArg) => createPlainDateTime(internal.plainDateTimeWithPlainTime(slots, optionalToPlainTimeFields(plainTimeArg))),
add: (slots, durationArg, options) => createPlainDateTime(internal.movePlainDateTime(internal.createNativeStandardOps, 0, slots, toDurationSlots(durationArg), options)),
subtract: (slots, durationArg, options) => createPlainDateTime(internal.movePlainDateTime(internal.createNativeStandardOps, 1, slots, toDurationSlots(durationArg), options)),
until: (slots, otherArg, options) => createDuration(internal.diffPlainDateTimes(internal.createNativeStandardOps, 0, slots, toPlainDateTimeSlots(otherArg), options)),
since: (slots, otherArg, options) => createDuration(internal.diffPlainDateTimes(internal.createNativeStandardOps, 1, slots, toPlainDateTimeSlots(otherArg), options)),
round: (slots, options) => createPlainDateTime(internal.roundPlainDateTime(slots, options)),
equals: (slots, otherArg) => internal.plainDateTimesEqual(slots, toPlainDateTimeSlots(otherArg)),
toZonedDateTime: (slots, timeZoneArg, options) => createZonedDateTime(internal.plainDateTimeToZonedDateTime(internal.queryNativeTimeZone, slots, refineTimeZoneArg(timeZoneArg), options)),
toPlainDate: slots => createPlainDate(internal.createPlainDateSlots(slots)),
toPlainTime: slots => createPlainTime(internal.createPlainTimeSlots(slots)),
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepPlainDateTimeFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: internal.formatPlainDateTimeIso,
toJSON: slots => internal.formatPlainDateTimeIso(slots),
valueOf: neverValueOf
}, {
from: (arg, options) => createPlainDateTime(toPlainDateTimeSlots(arg, options)),
compare: (arg0, arg1) => internal.compareIsoDateTimeFields(toPlainDateTimeSlots(arg0), toPlainDateTimeSlots(arg1))
}, internal.formatPlainDateTimeIso), [PlainMonthDay, createPlainMonthDay, getPlainMonthDaySlots] = createSlotClass(internal.PlainMonthDayBranding, internal.bindArgs(internal.constructPlainMonthDaySlots, internal.refineCalendarId), {
...calendarIdGetters,
...monthDayGetters
}, {
with: (slots, mod, options) => createPlainMonthDay(internal.plainMonthDayWithFields(internal.createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
equals: (slots, otherArg) => internal.plainMonthDaysEqual(slots, toPlainMonthDaySlots(otherArg)),
toPlainDate(slots, bag) {
return createPlainDate(internal.plainMonthDayToPlainDate(internal.createNativeStandardOps, slots, this, bag));
},
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepPlainMonthDayFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: internal.formatPlainMonthDayIso,
toJSON: slots => internal.formatPlainMonthDayIso(slots),
valueOf: neverValueOf
}, {
from: (arg, options) => createPlainMonthDay(toPlainMonthDaySlots(arg, options))
}, internal.formatPlainMonthDayIso), [PlainYearMonth, createPlainYearMonth, getPlainYearMonthSlots] = createSlotClass(internal.PlainYearMonthBranding, internal.bindArgs(internal.constructPlainYearMonthSlots, internal.refineCalendarId), {
...calendarIdGetters,
...yearMonthGetters
}, {
with: (slots, mod, options) => createPlainYearMonth(internal.plainYearMonthWithFields(internal.createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
add: (slots, durationArg, options) => createPlainYearMonth(internal.movePlainYearMonth(internal.createNativeStandardOps, 0, slots, toDurationSlots(durationArg), options)),
subtract: (slots, durationArg, options) => createPlainYearMonth(internal.movePlainYearMonth(internal.createNativeStandardOps, 1, slots, toDurationSlots(durationArg), options)),
until: (slots, otherArg, options) => createDuration(internal.diffPlainYearMonth(internal.createNativeStandardOps, 0, slots, toPlainYearMonthSlots(otherArg), options)),
since: (slots, otherArg, options) => createDuration(internal.diffPlainYearMonth(internal.createNativeStandardOps, 1, slots, toPlainYearMonthSlots(otherArg), options)),
equals: (slots, otherArg) => internal.plainYearMonthsEqual(slots, toPlainYearMonthSlots(otherArg)),
toPlainDate(slots, bag) {
return createPlainDate(internal.plainYearMonthToPlainDate(internal.createNativeStandardOps, slots, this, bag));
},
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepPlainYearMonthFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: internal.formatPlainYearMonthIso,
toJSON: slots => internal.formatPlainYearMonthIso(slots),
valueOf: neverValueOf
}, {
from: (arg, options) => createPlainYearMonth(toPlainYearMonthSlots(arg, options)),
compare: (arg0, arg1) => internal.compareIsoDateFields(toPlainYearMonthSlots(arg0), toPlainYearMonthSlots(arg1))
}, internal.formatPlainYearMonthIso), [PlainDate, createPlainDate, getPlainDateSlots] = createSlotClass(internal.PlainDateBranding, internal.bindArgs(internal.constructPlainDateSlots, internal.refineCalendarId), {
...calendarIdGetters,
...dateGetters
}, {
with: (slots, mod, options) => createPlainDate(internal.plainDateWithFields(internal.createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
withCalendar: (slots, calendarArg) => createPlainDate(internal.slotsWithCalendarId(slots, refineCalendarArg(calendarArg))),
add: (slots, durationArg, options) => createPlainDate(internal.movePlainDate(internal.createNativeStandardOps, 0, slots, toDurationSlots(durationArg), options)),
subtract: (slots, durationArg, options) => createPlainDate(internal.movePlainDate(internal.createNativeStandardOps, 1, slots, toDurationSlots(durationArg), options)),
until: (slots, otherArg, options) => createDuration(internal.diffPlainDates(internal.createNativeStandardOps, 0, slots, toPlainDateSlots(otherArg), options)),
since: (slots, otherArg, options) => createDuration(internal.diffPlainDates(internal.createNativeStandardOps, 1, slots, toPlainDateSlots(otherArg), options)),
equals: (slots, otherArg) => internal.plainDatesEqual(slots, toPlainDateSlots(otherArg)),
toZonedDateTime(slots, options) {
const optionsObj = internal.isObjectLike(options) ? options : {
timeZone: options
};
return createZonedDateTime(internal.plainDateToZonedDateTime(refineTimeZoneArg, toPlainTimeSlots, internal.queryNativeTimeZone, slots, optionsObj));
},
toPlainDateTime: (slots, plainTimeArg) => createPlainDateTime(internal.plainDateToPlainDateTime(slots, optionalToPlainTimeFields(plainTimeArg))),
toPlainYearMonth(slots) {
return createPlainYearMonth(internal.plainDateToPlainYearMonth(internal.createNativeStandardOps, slots, this));
},
toPlainMonthDay(slots) {
return createPlainMonthDay(internal.plainDateToPlainMonthDay(internal.createNativeStandardOps, slots, this));
},
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepPlainDateFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: internal.formatPlainDateIso,
toJSON: slots => internal.formatPlainDateIso(slots),
valueOf: neverValueOf
}, {
from: (arg, options) => createPlainDate(toPlainDateSlots(arg, options)),
compare: (arg0, arg1) => internal.compareIsoDateFields(toPlainDateSlots(arg0), toPlainDateSlots(arg1))
}, internal.formatPlainDateIso), [ZonedDateTime, createZonedDateTime] = createSlotClass(internal.ZonedDateTimeBranding, internal.bindArgs(internal.constructZonedDateTimeSlots, internal.refineCalendarId, internal.refineTimeZoneId), {
...epochGetters,
...calendarIdGetters,
...adaptDateMethods(dateGetters),
...adaptDateMethods(timeGetters),
offset: slots => internal.formatOffsetNano(slotsToIso(slots).offsetNanoseconds),
offsetNanoseconds: slots => slotsToIso(slots).offsetNanoseconds,
timeZoneId: slots => slots.timeZone,
hoursInDay: slots => internal.computeZonedHoursInDay(internal.queryNativeTimeZone, slots)
}, {
with: (slots, mod, options) => createZonedDateTime(internal.zonedDateTimeWithFields(internal.createNativeStandardOps, internal.queryNativeTimeZone, slots, rejectInvalidBag(mod), options)),
withCalendar: (slots, calendarArg) => createZonedDateTime(internal.slotsWithCalendarId(slots, refineCalendarArg(calendarArg))),
withTimeZone: (slots, timeZoneArg) => createZonedDateTime(internal.slotsWithTimeZoneId(slots, refineTimeZoneArg(timeZoneArg))),
withPlainTime: (slots, plainTimeArg) => createZonedDateTime(internal.zonedDateTimeWithPlainTime(internal.queryNativeTimeZone, slots, optionalToPlainTimeFields(plainTimeArg))),
add: (slots, durationArg, options) => createZonedDateTime(internal.moveZonedDateTime(internal.createNativeStandardOps, internal.queryNativeTimeZone, 0, slots, toDurationSlots(durationArg), options)),
subtract: (slots, durationArg, options) => createZonedDateTime(internal.moveZonedDateTime(internal.createNativeStandardOps, internal.queryNativeTimeZone, 1, slots, toDurationSlots(durationArg), options)),
until: (slots, otherArg, options) => createDuration(internal.createDurationSlots(internal.diffZonedDateTimes(internal.createNativeStandardOps, internal.queryNativeTimeZone, 0, slots, toZonedDateTimeSlots(otherArg), options))),
since: (slots, otherArg, options) => createDuration(internal.createDurationSlots(internal.diffZonedDateTimes(internal.createNativeStandardOps, internal.queryNativeTimeZone, 1, slots, toZonedDateTimeSlots(otherArg), options))),
round: (slots, options) => createZonedDateTime(internal.roundZonedDateTime(internal.queryNativeTimeZone, slots, options)),
startOfDay: slots => createZonedDateTime(internal.computeZonedStartOfDay(internal.queryNativeTimeZone, slots)),
equals: (slots, otherArg) => internal.zonedDateTimesEqual(slots, toZonedDateTimeSlots(otherArg)),
toInstant: slots => createInstant(internal.zonedDateTimeToInstant(slots)),
toPlainDateTime: slots => createPlainDateTime(internal.zonedDateTimeToPlainDateTime(internal.queryNativeTimeZone, slots)),
toPlainDate: slots => createPlainDate(internal.zonedDateTimeToPlainDate(internal.queryNativeTimeZone, slots)),
toPlainTime: slots => createPlainTime(internal.zonedDateTimeToPlainTime(internal.queryNativeTimeZone, slots)),
toLocaleString(slots, locales, options = {}) {
const [format, epochMilli] = prepZonedDateTimeFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: (slots, options) => internal.formatZonedDateTimeIso(internal.queryNativeTimeZone, slots, options),
toJSON: slots => internal.formatZonedDateTimeIso(internal.queryNativeTimeZone, slots),
valueOf: neverValueOf,
getTimeZoneTransition(slots, options) {
const {timeZone: timeZoneId, epochNanoseconds: epochNano} = slots, direction = internal.refineDirectionOptions(options), newEpochNano = internal.queryNativeTimeZone(timeZoneId).getTransition(epochNano, direction);
return newEpochNano ? createZonedDateTime({
...slots,
epochNanoseconds: newEpochNano
}) : null;
}
}, {
from: (arg, options) => createZonedDateTime(toZonedDateTimeSlots(arg, options)),
compare: (arg0, arg1) => internal.compareZonedDateTimes(toZonedDateTimeSlots(arg0), toZonedDateTimeSlots(arg1))
}, (slots => internal.formatZonedDateTimeIso(internal.queryNativeTimeZone, slots))), [Instant, createInstant, getInstantSlots] = createSlotClass(internal.InstantBranding, internal.constructInstantSlots, epochGetters, {
add: (slots, durationArg) => createInstant(internal.moveInstant(0, slots, toDurationSlots(durationArg))),
subtract: (slots, durationArg) => createInstant(internal.moveInstant(1, slots, toDurationSlots(durationArg))),
until: (slots, otherArg, options) => createDuration(internal.diffInstants(0, slots, toInstantSlots(otherArg), options)),
since: (slots, otherArg, options) => createDuration(internal.diffInstants(1, slots, toInstantSlots(otherArg), options)),
round: (slots, options) => createInstant(internal.roundInstant(slots, options)),
equals: (slots, otherArg) => internal.instantsEqual(slots, toInstantSlots(otherArg)),
toZonedDateTimeISO: (slots, timeZoneArg) => createZonedDateTime(internal.instantToZonedDateTime(slots, refineTimeZoneArg(timeZoneArg))),
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepInstantFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: (slots, options) => internal.formatInstantIso(refineTimeZoneArg, internal.queryNativeTimeZone, slots, options),
toJSON: slots => internal.formatInstantIso(refineTimeZoneArg, internal.queryNativeTimeZone, slots),
valueOf: neverValueOf
}, {
from: arg => createInstant(toInstantSlots(arg)),
fromEpochMilliseconds: epochMilli => createInstant(internal.epochMilliToInstant(epochMilli)),
fromEpochNanoseconds: epochNano => createInstant(internal.epochNanoToInstant(epochNano)),
compare: (a, b) => internal.compareInstants(toInstantSlots(a), toInstantSlots(b))
}, (slots => internal.formatInstantIso(refineTimeZoneArg, internal.queryNativeTimeZone, slots))), Now = Object.defineProperties({}, {
...internal.createStringTagDescriptors("Temporal.Now"),
...internal.createPropDescriptors({
timeZoneId: () => internal.getCurrentTimeZoneId(),
instant: () => createInstant(internal.createInstantSlots(internal.getCurrentEpochNano())),
zonedDateTimeISO: (timeZoneArg = internal.getCurrentTimeZoneId()) => createZonedDateTime(internal.createZonedDateTimeSlots(internal.getCurrentEpochNano(), refineTimeZoneArg(timeZoneArg), internal.isoCalendarId)),
plainDateTimeISO: (timeZoneArg = internal.getCurrentTimeZoneId()) => createPlainDateTime(internal.createPlainDateTimeSlots(internal.getCurrentIsoDateTime(internal.queryNativeTimeZone(refineTimeZoneArg(timeZoneArg))), internal.isoCalendarId)),
plainDateISO: (timeZoneArg = internal.getCurrentTimeZoneId()) => createPlainDate(internal.createPlainDateSlots(internal.getCurrentIsoDateTime(internal.queryNativeTimeZone(refineTimeZoneArg(timeZoneArg))), internal.isoCalendarId)),
plainTimeISO: (timeZoneArg = internal.getCurrentTimeZoneId()) => createPlainTime(internal.createPlainTimeSlots(internal.getCurrentIsoDateTime(internal.queryNativeTimeZone(refineTimeZoneArg(timeZoneArg)))))
})
}), Temporal = Object.defineProperties({}, {
...internal.createStringTagDescriptors("Temporal"),
...internal.createPropDescriptors({
PlainYearMonth: PlainYearMonth,
PlainMonthDay: PlainMonthDay,
PlainDate: PlainDate,
PlainTime: PlainTime,
PlainDateTime: PlainDateTime,
ZonedDateTime: ZonedDateTime,
Instant: Instant,
Duration: Duration,
Now: Now
})
}), DateTimeFormat = function() {
function DateTimeFormatFunc(locales, options) {
return new DateTimeFormatNew(locales, options);
}
function DateTimeFormatNew(locales, options = Object.create(null)) {
internalsMap.set(this, ((locales, options) => {
const rawFormat = new internal.RawDateTimeFormat(locales, options), resolveOptions = rawFormat.resolvedOptions(), resolvedLocale = resolveOptions.locale, copiedOptions = internal.pluckProps(Object.keys(options), resolveOptions), queryFormatPrepperForBranding = internal.memoize(createFormatPrepperForBranding), prepFormat = (isRange, ...formattables) => {
if (isRange) {
if (2 !== formattables.length) {
throw new TypeError(internal.mismatchingFormatTypes);
}
for (const formattable of formattables) {
if (void 0 === formattable) {
throw new TypeError(internal.mismatchingFormatTypes);
}
}
}
isRange || void 0 !== formattables[0] || (formattables = []);
const formattableEssences = formattables.map((formattable => getSlots(formattable) || Number(formattable)));
let overallBranding, i = 0;
for (const formattableEssence of formattableEssences) {
const slotsBranding = "object" == typeof formattableEssence ? formattableEssence.branding : void 0;
if (i++ && slotsBranding !== overallBranding) {
throw new TypeError(internal.mismatchingFormatTypes);
}
overallBranding = slotsBranding;
}
return overallBranding ? queryFormatPrepperForBranding(overallBranding)(resolvedLocale, copiedOptions, ...formattableEssences) : [ rawFormat, ...formattableEssences ];
};
return prepFormat.rawFormat = rawFormat, prepFormat;
})(locales, options));
}
const members = internal.RawDateTimeFormat.prototype, memberDescriptors = Object.getOwnPropertyDescriptors(members), classDescriptors = Object.getOwnPropertyDescriptors(internal.RawDateTimeFormat);
for (const memberName in memberDescriptors) {
const memberDescriptor = memberDescriptors[memberName], formatLikeMethod = memberName.startsWith("format") && createFormatMethod(memberName);
"function" == typeof memberDescriptor.value ? memberDescriptor.value = "constructor" === memberName ? DateTimeFormatFunc : formatLikeMethod || createProxiedMethod(memberName) : formatLikeMethod && (memberDescriptor.get = function() {
if (!internalsMap.has(this)) {
throw new TypeError(internal.invalidCallingContext);
}
return (...args) => formatLikeMethod.apply(this, args);
}, Object.defineProperties(memberDescriptor.get, internal.createNameDescriptors(`get ${memberName}`)));
}
return classDescriptors.prototype.value = DateTimeFormatNew.prototype = Object.create({}, memberDescriptors),
Object.defineProperties(DateTimeFormatFunc, classDescriptors), DateTimeFormatFunc;
}(), internalsMap = new WeakMap, IntlExtended = Object.defineProperties(Object.create(Intl), internal.createPropDescriptors({
DateTimeFormat: DateTimeFormat
}));
exports.DateTimeFormat = DateTimeFormat, exports.IntlExtended = IntlExtended, exports.Temporal = Temporal,
exports.toTemporalInstant = function() {
const epochMilli = Date.prototype.valueOf.call(this);
return createInstant(internal.createInstantSlots(internal.numberToBigNano(internal.requireNumberIsInteger(epochMilli), internal.nanoInMilli)));
};
@@ -0,0 +1,594 @@
function createSlotClass(i, l, s, c, u, f) {
function Class(...t) {
if (!(this instanceof Class)) {
throw new TypeError(a);
}
{
const e = l(...t);
un(this, e), dbg(this, e, f);
}
}
function bindMethod(t, e) {
return Object.defineProperties((function(...e) {
return t.call(this, getSpecificSlots(this), ...e);
}), r(e));
}
function getSpecificSlots(t) {
const e = cn(t);
if (!e || e.branding !== i) {
throw new TypeError(a);
}
return e;
}
return Object.defineProperties(Class.prototype, {
...t(e(bindMethod, s)),
...n(e(bindMethod, c)),
...o("Temporal." + i)
}), Object.defineProperties(Class, {
...n(u),
...r(i)
}), [ Class, t => {
const e = Object.create(Class.prototype);
return un(e, t), dbg(e, t, f), e;
}, getSpecificSlots ];
}
function rejectInvalidBag(t) {
if (cn(t) || void 0 !== t.calendar || void 0 !== t.timeZone) {
throw new TypeError(i);
}
return t;
}
function dbg(t, e, n) {
"dbg" === dbg.name && Object.defineProperty(t, "o", {
value: n(e),
writable: 0,
enumerable: 0,
configurable: 0
});
}
function getCalendarIdFromBag(t) {
return extractCalendarIdFromBag(t) || l;
}
function extractCalendarIdFromBag(t) {
const {calendar: e} = t;
if (void 0 !== e) {
return refineCalendarArg(e);
}
}
function refineCalendarArg(t) {
if (s(t)) {
const {calendar: e} = cn(t) || {};
if (!e) {
throw new TypeError(c(t));
}
return e;
}
return (t => u(f(d(t))))(t);
}
function createCalendarGetters(t) {
const e = {};
for (const n in t) {
e[n] = t => {
const {calendar: e} = t;
return v(e)[n](t);
};
}
return e;
}
function neverValueOf() {
throw new TypeError(C);
}
function refineTimeZoneArg(t) {
if (s(t)) {
const {timeZone: e} = cn(t) || {};
if (!e) {
throw new TypeError(F(t));
}
return e;
}
return (t => Z(M(d(t))))(t);
}
function toDurationSlots(t) {
if (s(t)) {
const e = cn(t);
return e && e.branding === A ? e : q(t);
}
return R(t);
}
function refinePublicRelativeTo(t) {
if (void 0 !== t) {
if (s(t)) {
const e = cn(t) || {};
switch (e.branding) {
case _:
case G:
return e;
case x:
return W(e);
}
const n = getCalendarIdFromBag(t);
return {
...z(refineTimeZoneArg, L, v(n), t),
calendar: n
};
}
return $(t);
}
}
function toPlainTimeSlots(t, e) {
if (s(t)) {
const n = cn(t) || {};
switch (n.branding) {
case ft:
return dt(e), n;
case x:
return dt(e), St(n);
case _:
return dt(e), mt(L, n);
}
return Tt(t, e);
}
const n = ht(t);
return dt(e), n;
}
function optionalToPlainTimeFields(t) {
return void 0 === t ? void 0 : toPlainTimeSlots(t);
}
function toPlainDateTimeSlots(t, e) {
if (s(t)) {
const n = cn(t) || {};
switch (n.branding) {
case x:
return dt(e), n;
case G:
return dt(e), jt({
...n,
...At
});
case _:
return dt(e), yt(L, n);
}
return Nt(v(getCalendarIdFromBag(t)), t, e);
}
const n = Bt(t);
return dt(e), n;
}
function toPlainMonthDaySlots(t, e) {
if (s(t)) {
const n = cn(t);
if (n && n.branding === qt) {
return dt(e), n;
}
const o = extractCalendarIdFromBag(t);
return Rt(v(o || l), !o, t, e);
}
const n = xt(v, t);
return dt(e), n;
}
function toPlainYearMonthSlots(t, e) {
if (s(t)) {
const n = cn(t);
return n && n.branding === Qt ? (dt(e), n) : Ut(v(getCalendarIdFromBag(t)), t, e);
}
const n = Xt(v, t);
return dt(e), n;
}
function toPlainDateSlots(t, e) {
if (s(t)) {
const n = cn(t) || {};
switch (n.branding) {
case G:
return dt(e), n;
case x:
return dt(e), W(n);
case _:
return dt(e), fe(L, n);
}
return de(v(getCalendarIdFromBag(t)), t, e);
}
const n = me(t);
return dt(e), n;
}
function toZonedDateTimeSlots(t, e) {
if (s(t)) {
const n = cn(t);
if (n && n.branding === _) {
return je(e), n;
}
const o = getCalendarIdFromBag(t);
return Ae(refineTimeZoneArg, L, v(o), o, t, e);
}
return Ne(t, e);
}
function adaptDateMethods(t) {
return e((t => e => t(slotsToIso(e))), t);
}
function slotsToIso(t) {
return he(t, L);
}
function toInstantSlots(t) {
if (s(t)) {
const e = cn(t);
if (e) {
switch (e.branding) {
case Re:
return e;
case _:
return xe(e.epochNanoseconds);
}
}
}
return We(t);
}
function toTemporalInstant() {
const t = Date.prototype.valueOf.call(this);
return Hn(xe(Ge(_e(t), Ke)));
}
function createDateTimeFormatClass() {
function DateTimeFormatFunc(t, e) {
return new DateTimeFormatNew(t, e);
}
function DateTimeFormatNew(t, e = Object.create(null)) {
to.set(this, ((t, e) => {
const n = new en(t, e), o = n.resolvedOptions(), r = o.locale, a = nn(Object.keys(e), o), i = on(createFormatPrepperForBranding), prepFormat = (t, ...e) => {
if (t) {
if (2 !== e.length) {
throw new TypeError(ln);
}
for (const t of e) {
if (void 0 === t) {
throw new TypeError(ln);
}
}
}
t || void 0 !== e[0] || (e = []);
const o = e.map((t => cn(t) || Number(t)));
let l, s = 0;
for (const t of o) {
const e = "object" == typeof t ? t.branding : void 0;
if (s++ && e !== l) {
throw new TypeError(ln);
}
l = e;
}
return l ? i(l)(r, a, ...o) : [ n, ...o ];
};
return prepFormat.i = n, prepFormat;
})(t, e));
}
const t = en.prototype, e = Object.getOwnPropertyDescriptors(t), n = Object.getOwnPropertyDescriptors(en);
for (const t in e) {
const n = e[t], o = t.startsWith("format") && createFormatMethod(t);
"function" == typeof n.value ? n.value = "constructor" === t ? DateTimeFormatFunc : o || createProxiedMethod(t) : o && (n.get = function() {
if (!to.has(this)) {
throw new TypeError(a);
}
return (...t) => o.apply(this, t);
}, Object.defineProperties(n.get, r(`get ${t}`)));
}
return n.prototype.value = DateTimeFormatNew.prototype = Object.create({}, e), Object.defineProperties(DateTimeFormatFunc, n),
DateTimeFormatFunc;
}
function createFormatMethod(t) {
return Object.defineProperties((function(...e) {
const n = to.get(this), [o, ...r] = n(t.includes("Range"), ...e);
return o[t](...r);
}), r(t));
}
function createProxiedMethod(t) {
return Object.defineProperties((function(...e) {
return to.get(this).i[t](...e);
}), r(t));
}
function createFormatPrepperForBranding(t) {
const e = vn[t];
if (!e) {
throw new TypeError(rn(t));
}
return K(e, on(an), 1);
}
import { createGetterDescriptors as t, mapProps as e, createPropDescriptors as n, createStringTagDescriptors as o, createNameDescriptors as r, invalidCallingContext as a, invalidBag as i, isoCalendarId as l, isObjectLike as s, invalidCalendar as c, resolveCalendarId as u, parseCalendarId as f, requireString as d, requireStringOrUndefined as m, requireIntegerOrUndefined as S, requireInteger as T, requirePositiveInteger as h, requireBoolean as D, requirePositiveIntegerOrUndefined as g, mapPropNames as P, durationFieldNamesAsc as O, timeFieldNamesAsc as p, isoTimeFieldNamesAsc as w, getEpochMilli as I, getEpochNano as b, createNativeStandardOps as v, forbiddenValueOf as C, invalidTimeZone as F, resolveTimeZoneId as Z, parseTimeZoneId as M, getDurationBlank as y, constructDurationSlots as j, DurationBranding as A, durationWithFields as N, negateDuration as B, absDuration as Y, addDurations as E, queryNativeTimeZone as L, roundDuration as V, totalDuration as J, formatDurationIso as k, refineDurationBag as q, parseDuration as R, PlainDateTimeBranding as x, createPlainDateSlots as W, PlainDateBranding as G, ZonedDateTimeBranding as _, refineMaybeZonedDateTimeBag as z, parseRelativeToSlots as $, compareDurations as H, createFormatPrepper as K, instantConfig as Q, dateTimeConfig as U, dateConfig as X, timeConfig as tt, yearMonthConfig as et, monthDayConfig as nt, zonedConfig as ot, plainTimeWithFields as rt, movePlainTime as at, diffPlainTimes as it, roundPlainTime as lt, plainTimesEqual as st, formatPlainTimeIso as ct, constructPlainTimeSlots as ut, PlainTimeBranding as ft, refineOverflowOptions as dt, zonedDateTimeToPlainTime as mt, createPlainTimeSlots as St, refinePlainTimeBag as Tt, parsePlainTime as ht, compareIsoTimeFields as Dt, bindArgs as gt, plainDateTimeWithFields as Pt, slotsWithCalendarId as Ot, plainDateTimeWithPlainTime as pt, movePlainDateTime as wt, diffPlainDateTimes as It, roundPlainDateTime as bt, plainDateTimesEqual as vt, plainDateTimeToZonedDateTime as Ct, formatPlainDateTimeIso as Ft, refineCalendarId as Zt, constructPlainDateTimeSlots as Mt, zonedDateTimeToPlainDateTime as yt, createPlainDateTimeSlots as jt, isoTimeFieldDefaults as At, refinePlainDateTimeBag as Nt, parsePlainDateTime as Bt, compareIsoDateTimeFields as Yt, plainMonthDayWithFields as Et, plainMonthDaysEqual as Lt, plainMonthDayToPlainDate as Vt, formatPlainMonthDayIso as Jt, constructPlainMonthDaySlots as kt, PlainMonthDayBranding as qt, refinePlainMonthDayBag as Rt, parsePlainMonthDay as xt, plainYearMonthWithFields as Wt, movePlainYearMonth as Gt, diffPlainYearMonth as _t, plainYearMonthsEqual as zt, plainYearMonthToPlainDate as $t, formatPlainYearMonthIso as Ht, constructPlainYearMonthSlots as Kt, PlainYearMonthBranding as Qt, refinePlainYearMonthBag as Ut, parsePlainYearMonth as Xt, compareIsoDateFields as te, plainDateWithFields as ee, movePlainDate as ne, diffPlainDates as oe, plainDatesEqual as re, plainDateToZonedDateTime as ae, plainDateToPlainDateTime as ie, plainDateToPlainYearMonth as le, plainDateToPlainMonthDay as se, formatPlainDateIso as ce, constructPlainDateSlots as ue, zonedDateTimeToPlainDate as fe, refinePlainDateBag as de, parsePlainDate as me, formatOffsetNano as Se, computeZonedHoursInDay as Te, zonedEpochSlotsToIso as he, zonedDateTimeWithFields as De, slotsWithTimeZoneId as ge, zonedDateTimeWithPlainTime as Pe, moveZonedDateTime as Oe, createDurationSlots as pe, diffZonedDateTimes as we, roundZonedDateTime as Ie, computeZonedStartOfDay as be, zonedDateTimesEqual as ve, zonedDateTimeToInstant as Ce, formatZonedDateTimeIso as Fe, refineDirectionOptions as Ze, refineTimeZoneId as Me, constructZonedDateTimeSlots as ye, refineZonedFieldOptions as je, refineZonedDateTimeBag as Ae, parseZonedDateTime as Ne, compareZonedDateTimes as Be, moveInstant as Ye, diffInstants as Ee, roundInstant as Le, instantsEqual as Ve, instantToZonedDateTime as Je, formatInstantIso as ke, constructInstantSlots as qe, InstantBranding as Re, createInstantSlots as xe, parseInstant as We, numberToBigNano as Ge, requireNumberIsInteger as _e, epochMilliToInstant as ze, epochNanoToInstant as $e, compareInstants as He, nanoInMilli as Ke, getCurrentTimeZoneId as Qe, getCurrentEpochNano as Ue, createZonedDateTimeSlots as Xe, getCurrentIsoDateTime as tn, RawDateTimeFormat as en, pluckProps as nn, memoize as on, invalidFormatType as rn, createFormatForPrep as an, mismatchingFormatTypes as ln } from "./internal.js";
const sn = /*@__PURE__*/ new WeakMap, cn = /*@__PURE__*/ sn.get.bind(sn), un = /*@__PURE__*/ sn.set.bind(sn), fn = {
era: m,
eraYear: S,
year: T,
month: h,
daysInMonth: h,
daysInYear: h,
inLeapYear: D,
monthsInYear: h
}, dn = {
monthCode: d
}, mn = {
day: h
}, Sn = {
dayOfWeek: h,
dayOfYear: h,
weekOfYear: g,
yearOfWeek: S,
daysInWeek: h
}, Tn = /*@__PURE__*/ createCalendarGetters(/*@__PURE__*/ Object.assign({}, fn, dn, mn, Sn)), hn = /*@__PURE__*/ createCalendarGetters({
...fn,
...dn
}), Dn = /*@__PURE__*/ createCalendarGetters({
...dn,
...mn
}), gn = {
calendarId: t => t.calendar
}, Pn = /*@__PURE__*/ P((t => e => e[t]), O.concat("sign")), On = /*@__PURE__*/ P(((t, e) => t => t[w[e]]), p), pn = {
epochMilliseconds: I,
epochNanoseconds: b
}, [wn, In, bn] = createSlotClass(A, j, {
...Pn,
blank: y
}, {
with: (t, e) => In(N(t, e)),
negated: t => In(B(t)),
abs: t => In(Y(t)),
add: (t, e, n) => In(E(refinePublicRelativeTo, v, L, 0, t, toDurationSlots(e), n)),
subtract: (t, e, n) => In(E(refinePublicRelativeTo, v, L, 1, t, toDurationSlots(e), n)),
round: (t, e) => In(V(refinePublicRelativeTo, v, L, t, e)),
total: (t, e) => J(refinePublicRelativeTo, v, L, t, e),
toLocaleString(t, e, n) {
return Intl.DurationFormat ? new Intl.DurationFormat(e, n).format(this) : k(t);
},
toString: k,
toJSON: t => k(t),
valueOf: neverValueOf
}, {
from: t => In(toDurationSlots(t)),
compare: (t, e, n) => H(refinePublicRelativeTo, v, L, toDurationSlots(t), toDurationSlots(e), n)
}, k), vn = {
Instant: Q,
PlainDateTime: U,
PlainDate: X,
PlainTime: tt,
PlainYearMonth: et,
PlainMonthDay: nt
}, Cn = /*@__PURE__*/ K(Q), Fn = /*@__PURE__*/ K(ot), Zn = /*@__PURE__*/ K(U), Mn = /*@__PURE__*/ K(X), yn = /*@__PURE__*/ K(tt), jn = /*@__PURE__*/ K(et), An = /*@__PURE__*/ K(nt), [Nn, Bn] = createSlotClass(ft, ut, On, {
with(t, e, n) {
return Bn(rt(this, rejectInvalidBag(e), n));
},
add: (t, e) => Bn(at(0, t, toDurationSlots(e))),
subtract: (t, e) => Bn(at(1, t, toDurationSlots(e))),
until: (t, e, n) => In(it(0, t, toPlainTimeSlots(e), n)),
since: (t, e, n) => In(it(1, t, toPlainTimeSlots(e), n)),
round: (t, e) => Bn(lt(t, e)),
equals: (t, e) => st(t, toPlainTimeSlots(e)),
toLocaleString(t, e, n) {
const [o, r] = yn(e, n, t);
return o.format(r);
},
toString: ct,
toJSON: t => ct(t),
valueOf: neverValueOf
}, {
from: (t, e) => Bn(toPlainTimeSlots(t, e)),
compare: (t, e) => Dt(toPlainTimeSlots(t), toPlainTimeSlots(e))
}, ct), [Yn, En] = createSlotClass(x, gt(Mt, Zt), {
...gn,
...Tn,
...On
}, {
with: (t, e, n) => En(Pt(v, t, rejectInvalidBag(e), n)),
withCalendar: (t, e) => En(Ot(t, refineCalendarArg(e))),
withPlainTime: (t, e) => En(pt(t, optionalToPlainTimeFields(e))),
add: (t, e, n) => En(wt(v, 0, t, toDurationSlots(e), n)),
subtract: (t, e, n) => En(wt(v, 1, t, toDurationSlots(e), n)),
until: (t, e, n) => In(It(v, 0, t, toPlainDateTimeSlots(e), n)),
since: (t, e, n) => In(It(v, 1, t, toPlainDateTimeSlots(e), n)),
round: (t, e) => En(bt(t, e)),
equals: (t, e) => vt(t, toPlainDateTimeSlots(e)),
toZonedDateTime: (t, e, n) => zn(Ct(L, t, refineTimeZoneArg(e), n)),
toPlainDate: t => Wn(W(t)),
toPlainTime: t => Bn(St(t)),
toLocaleString(t, e, n) {
const [o, r] = Zn(e, n, t);
return o.format(r);
},
toString: Ft,
toJSON: t => Ft(t),
valueOf: neverValueOf
}, {
from: (t, e) => En(toPlainDateTimeSlots(t, e)),
compare: (t, e) => Yt(toPlainDateTimeSlots(t), toPlainDateTimeSlots(e))
}, Ft), [Ln, Vn, Jn] = createSlotClass(qt, gt(kt, Zt), {
...gn,
...Dn
}, {
with: (t, e, n) => Vn(Et(v, t, rejectInvalidBag(e), n)),
equals: (t, e) => Lt(t, toPlainMonthDaySlots(e)),
toPlainDate(t, e) {
return Wn(Vt(v, t, this, e));
},
toLocaleString(t, e, n) {
const [o, r] = An(e, n, t);
return o.format(r);
},
toString: Jt,
toJSON: t => Jt(t),
valueOf: neverValueOf
}, {
from: (t, e) => Vn(toPlainMonthDaySlots(t, e))
}, Jt), [kn, qn, Rn] = createSlotClass(Qt, gt(Kt, Zt), {
...gn,
...hn
}, {
with: (t, e, n) => qn(Wt(v, t, rejectInvalidBag(e), n)),
add: (t, e, n) => qn(Gt(v, 0, t, toDurationSlots(e), n)),
subtract: (t, e, n) => qn(Gt(v, 1, t, toDurationSlots(e), n)),
until: (t, e, n) => In(_t(v, 0, t, toPlainYearMonthSlots(e), n)),
since: (t, e, n) => In(_t(v, 1, t, toPlainYearMonthSlots(e), n)),
equals: (t, e) => zt(t, toPlainYearMonthSlots(e)),
toPlainDate(t, e) {
return Wn($t(v, t, this, e));
},
toLocaleString(t, e, n) {
const [o, r] = jn(e, n, t);
return o.format(r);
},
toString: Ht,
toJSON: t => Ht(t),
valueOf: neverValueOf
}, {
from: (t, e) => qn(toPlainYearMonthSlots(t, e)),
compare: (t, e) => te(toPlainYearMonthSlots(t), toPlainYearMonthSlots(e))
}, Ht), [xn, Wn, Gn] = createSlotClass(G, gt(ue, Zt), {
...gn,
...Tn
}, {
with: (t, e, n) => Wn(ee(v, t, rejectInvalidBag(e), n)),
withCalendar: (t, e) => Wn(Ot(t, refineCalendarArg(e))),
add: (t, e, n) => Wn(ne(v, 0, t, toDurationSlots(e), n)),
subtract: (t, e, n) => Wn(ne(v, 1, t, toDurationSlots(e), n)),
until: (t, e, n) => In(oe(v, 0, t, toPlainDateSlots(e), n)),
since: (t, e, n) => In(oe(v, 1, t, toPlainDateSlots(e), n)),
equals: (t, e) => re(t, toPlainDateSlots(e)),
toZonedDateTime(t, e) {
const n = s(e) ? e : {
timeZone: e
};
return zn(ae(refineTimeZoneArg, toPlainTimeSlots, L, t, n));
},
toPlainDateTime: (t, e) => En(ie(t, optionalToPlainTimeFields(e))),
toPlainYearMonth(t) {
return qn(le(v, t, this));
},
toPlainMonthDay(t) {
return Vn(se(v, t, this));
},
toLocaleString(t, e, n) {
const [o, r] = Mn(e, n, t);
return o.format(r);
},
toString: ce,
toJSON: t => ce(t),
valueOf: neverValueOf
}, {
from: (t, e) => Wn(toPlainDateSlots(t, e)),
compare: (t, e) => te(toPlainDateSlots(t), toPlainDateSlots(e))
}, ce), [_n, zn] = createSlotClass(_, gt(ye, Zt, Me), {
...pn,
...gn,
...adaptDateMethods(Tn),
...adaptDateMethods(On),
offset: t => Se(slotsToIso(t).offsetNanoseconds),
offsetNanoseconds: t => slotsToIso(t).offsetNanoseconds,
timeZoneId: t => t.timeZone,
hoursInDay: t => Te(L, t)
}, {
with: (t, e, n) => zn(De(v, L, t, rejectInvalidBag(e), n)),
withCalendar: (t, e) => zn(Ot(t, refineCalendarArg(e))),
withTimeZone: (t, e) => zn(ge(t, refineTimeZoneArg(e))),
withPlainTime: (t, e) => zn(Pe(L, t, optionalToPlainTimeFields(e))),
add: (t, e, n) => zn(Oe(v, L, 0, t, toDurationSlots(e), n)),
subtract: (t, e, n) => zn(Oe(v, L, 1, t, toDurationSlots(e), n)),
until: (t, e, n) => In(pe(we(v, L, 0, t, toZonedDateTimeSlots(e), n))),
since: (t, e, n) => In(pe(we(v, L, 1, t, toZonedDateTimeSlots(e), n))),
round: (t, e) => zn(Ie(L, t, e)),
startOfDay: t => zn(be(L, t)),
equals: (t, e) => ve(t, toZonedDateTimeSlots(e)),
toInstant: t => Hn(Ce(t)),
toPlainDateTime: t => En(yt(L, t)),
toPlainDate: t => Wn(fe(L, t)),
toPlainTime: t => Bn(mt(L, t)),
toLocaleString(t, e, n = {}) {
const [o, r] = Fn(e, n, t);
return o.format(r);
},
toString: (t, e) => Fe(L, t, e),
toJSON: t => Fe(L, t),
valueOf: neverValueOf,
getTimeZoneTransition(t, e) {
const {timeZone: n, epochNanoseconds: o} = t, r = Ze(e), a = L(n).l(o, r);
return a ? zn({
...t,
epochNanoseconds: a
}) : null;
}
}, {
from: (t, e) => zn(toZonedDateTimeSlots(t, e)),
compare: (t, e) => Be(toZonedDateTimeSlots(t), toZonedDateTimeSlots(e))
}, (t => Fe(L, t))), [$n, Hn, Kn] = createSlotClass(Re, qe, pn, {
add: (t, e) => Hn(Ye(0, t, toDurationSlots(e))),
subtract: (t, e) => Hn(Ye(1, t, toDurationSlots(e))),
until: (t, e, n) => In(Ee(0, t, toInstantSlots(e), n)),
since: (t, e, n) => In(Ee(1, t, toInstantSlots(e), n)),
round: (t, e) => Hn(Le(t, e)),
equals: (t, e) => Ve(t, toInstantSlots(e)),
toZonedDateTimeISO: (t, e) => zn(Je(t, refineTimeZoneArg(e))),
toLocaleString(t, e, n) {
const [o, r] = Cn(e, n, t);
return o.format(r);
},
toString: (t, e) => ke(refineTimeZoneArg, L, t, e),
toJSON: t => ke(refineTimeZoneArg, L, t),
valueOf: neverValueOf
}, {
from: t => Hn(toInstantSlots(t)),
fromEpochMilliseconds: t => Hn(ze(t)),
fromEpochNanoseconds: t => Hn($e(t)),
compare: (t, e) => He(toInstantSlots(t), toInstantSlots(e))
}, (t => ke(refineTimeZoneArg, L, t))), Qn = /*@__PURE__*/ Object.defineProperties({}, {
...o("Temporal.Now"),
...n({
timeZoneId: () => Qe(),
instant: () => Hn(xe(Ue())),
zonedDateTimeISO: (t = Qe()) => zn(Xe(Ue(), refineTimeZoneArg(t), l)),
plainDateTimeISO: (t = Qe()) => En(jt(tn(L(refineTimeZoneArg(t))), l)),
plainDateISO: (t = Qe()) => Wn(W(tn(L(refineTimeZoneArg(t))), l)),
plainTimeISO: (t = Qe()) => Bn(St(tn(L(refineTimeZoneArg(t)))))
})
}), Un = /*@__PURE__*/ Object.defineProperties({}, {
...o("Temporal"),
...n({
PlainYearMonth: kn,
PlainMonthDay: Ln,
PlainDate: xn,
PlainTime: Nn,
PlainDateTime: Yn,
ZonedDateTime: _n,
Instant: $n,
Duration: wn,
Now: Qn
})
}), Xn = /*@__PURE__*/ createDateTimeFormatClass(), to = /*@__PURE__*/ new WeakMap, eo = /*@__PURE__*/ Object.defineProperties(Object.create(Intl), n({
DateTimeFormat: Xn
}));
export { Xn as DateTimeFormat, eo as IntlExtended, Un as Temporal, toTemporalInstant };
@@ -0,0 +1,626 @@
"use strict";
function createFormatCache() {
const queryFormatFactory = internal.memoize((options => {
const map = new Map;
return (forcedTimeZoneId, locales, transformOptions) => {
const key = [].concat(forcedTimeZoneId || [], locales || []).join();
let format = map.get(key);
return format || (format = internal.createFormatForPrep(forcedTimeZoneId, locales, options, transformOptions, 0),
map.set(key, format)), format;
};
}), WeakMap);
return (forcedTimeZoneId, locales, options, transformOptions) => queryFormatFactory(options)(forcedTimeZoneId, locales, transformOptions);
}
function getCalendarId(slots) {
return slots.calendar;
}
function getCalendarIdFromBag(bag) {
return extractCalendarIdFromBag(bag) || internal.isoCalendarId;
}
function extractCalendarIdFromBag(bag) {
const {calendar: calendar} = bag;
if (void 0 !== calendar) {
return internal.refineCalendarId(calendar);
}
}
function computeDateFields(slots) {
const calendarOps = internal.createNativePartOps(slots.calendar), [year, month, day] = calendarOps.dateParts(slots), [era, eraYear] = calendarOps.eraParts(slots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month);
return {
era: era,
eraYear: eraYear,
year: year,
monthCode: internal.formatMonthCode(monthCodeNumber, isLeapMonth),
month: month,
day: day
};
}
function computeInLeapYear(slots) {
return internal.createNativeInLeapYearOps(slots.calendar).inLeapYear(slots);
}
function computeMonthsInYear(slots) {
return internal.createNativeMonthsInYearOps(slots.calendar).monthsInYear(slots);
}
function computeDaysInMonth(slots) {
return internal.createNativeDaysInMonthOps(slots.calendar).daysInMonth(slots);
}
function computeDaysInYear(slots) {
return internal.createNativeDaysInYearOps(slots.calendar).daysInYear(slots);
}
function computeDayOfYear(slots) {
return internal.createNativeDayOfYearOps(slots.calendar).dayOfYear(slots);
}
function computeWeekOfYear(slots) {
return internal.createNativeWeekOps(slots.calendar).weekOfYear(slots);
}
function computeYearOfWeek(slots) {
return internal.createNativeWeekOps(slots.calendar).yearOfWeek(slots);
}
function diffZonedLargeUnits(unit, record0, record1, options) {
const timeZoneId = internal.getCommonTimeZoneId(record0.timeZone, record1.timeZone), timeZoneOps = internal.queryNativeTimeZone(timeZoneId), calendarId = internal.getCommonCalendarId(record0.calendar, record1.calendar), calendarOps = internal.createNativeDiffOps(calendarId);
return diffDateUnits(internal.extractEpochNano, internal.bindArgs(internal.prepareZonedEpochDiff, timeZoneOps), internal.bindArgs(internal.moveZonedEpochs, timeZoneOps), ((f0, f1) => calendarOps.dateUntil(f0, f1, unit)), unit, calendarOps, record0, record1, options);
}
function diffPlainLargeUnits(unit, record0, record1, options) {
const calendarId = internal.getCommonCalendarId(record0.calendar, record1.calendar), calendarOps = internal.createNativeDiffOps(calendarId);
return diffDateUnits(internal.isoToEpochNano, identityMarkersToIsoFields, internal.moveDateTime, ((f0, f1) => calendarOps.dateUntil(f0, f1, unit)), unit, calendarOps, record0, record1, options);
}
function identityMarkersToIsoFields(m0, m1) {
return [ m0, m1 ];
}
function diffDateUnits(markerToEpochNano, markersToIsoFields, moveMarker, diffIsoFields, unit, calendarOps, marker0, marker1, options) {
const [roundingInc, roundingMode] = internal.refineUnitDiffOptions(unit, options), startEpochNano = markerToEpochNano(marker0), endEpochNano = markerToEpochNano(marker1), sign = internal.compareBigNanos(endEpochNano, startEpochNano);
if (!sign) {
return 0;
}
const [isoFields0, isoFields1] = markersToIsoFields(marker0, marker1, sign), durationFields = diffIsoFields(isoFields0, isoFields1);
let res = internal.totalRelativeDuration(durationFields, endEpochNano, unit, calendarOps, marker0, markerToEpochNano, moveMarker);
return roundingInc && (res = internal.roundByInc(res, roundingInc, roundingMode)),
res;
}
function diffZonedDayLikeUnits(unit, daysInUnit, record0, record1, options) {
const [roundingInc, roundingMode] = internal.refineUnitDiffOptions(unit, options), timeZoneId = internal.getCommonTimeZoneId(record0.timeZone, record1.timeZone), timeZoneOps = internal.queryNativeTimeZone(timeZoneId), sign = internal.compareBigNanos(record1.epochNanoseconds, record0.epochNanoseconds), [isoFields0, isoFields1, remainderNano] = internal.prepareZonedEpochDiff(timeZoneOps, record0, record1, sign), nanoDiff = internal.moveBigNano(internal.diffBigNanos(internal.isoToEpochNano(isoFields0), internal.isoToEpochNano(isoFields1)), remainderNano);
let res = internal.bigNanoToExactDays(nanoDiff) / daysInUnit;
return roundingInc && (res = internal.roundByInc(res, roundingInc, roundingMode)),
res;
}
function diffPlainDayLikeUnit(markerToEpochNano, unit, daysInUnit, record0, record1, options) {
const [roundingInc, roundingMode] = internal.refineUnitDiffOptions(unit, options), nanoDiff = internal.diffBigNanos(markerToEpochNano(record0), markerToEpochNano(record1));
let res = internal.bigNanoToExactDays(nanoDiff) / daysInUnit;
return roundingInc && (res = internal.roundByInc(res, roundingInc, roundingMode)),
res;
}
function diffTimeUnit(markerToEpochNano, unit, nanoInUnit, record0, record1, options) {
const [roundingInc, roundingMode] = internal.refineUnitDiffOptions(unit, options);
let nanoDiff = internal.diffBigNanos(markerToEpochNano(record0), markerToEpochNano(record1));
return roundingInc && (nanoDiff = internal.roundBigNanoByInc(nanoDiff, nanoInUnit * roundingInc, roundingMode)),
internal.bigNanoToNumber(nanoDiff, nanoInUnit, !roundingInc);
}
function reversedMove(f) {
return (slots, units, options) => f(slots, -units, options);
}
function moveByYears(slots, years, options) {
const overflow = internal.refineOverflowOptions(options);
if (!years) {
return slots;
}
const calendarOps = internal.createNativeMoveOps(slots.calendar), isoFields = internal.epochMilliToIso(internal.nativeYearMonthAdd(calendarOps, slots, internal.toStrictInteger(years), 0, overflow)), isoDateFields = internal.pluckProps(internal.isoDateFieldNamesAlpha, isoFields);
return {
...slots,
...isoDateFields
};
}
function moveByMonths(slots, months, options) {
const overflow = internal.refineOverflowOptions(options);
if (!months) {
return slots;
}
const calendarOps = internal.createNativeMoveOps(slots.calendar), isoFields = internal.epochMilliToIso(internal.nativeYearMonthAdd(calendarOps, slots, 0, internal.toStrictInteger(months), overflow)), isoDateFields = internal.pluckProps(internal.isoDateFieldNamesAlpha, isoFields);
return {
...slots,
...isoDateFields
};
}
function moveByIsoWeeks(slots, weeks) {
return internal.moveByDays(slots, 7 * internal.toStrictInteger(weeks));
}
function moveByDaysStrict(slots, weeks) {
return internal.moveByDays(slots, internal.toStrictInteger(weeks));
}
function moveToDayOfYear(slots, dayOfYear, options) {
const overflow = internal.refineOverflowOptions(options), {calendar: calendar} = slots, daysInYear = internal.createNativeDaysInYearOps(calendar).daysInYear(slots), normDayOfYear = internal.clampEntity(dayOfMonthLabel, internal.toInteger(dayOfYear, dayOfMonthLabel), 1, daysInYear, overflow), currentDayOfYear = internal.createNativeDayOfYearOps(calendar).dayOfYear(slots);
return internal.moveByDays(slots, normDayOfYear - currentDayOfYear);
}
function moveToDayOfMonth(slots, day, options) {
const overflow = internal.refineOverflowOptions(options), {calendar: calendar} = slots, daysInMonth = internal.createNativeDaysInMonthOps(calendar).daysInMonth(slots), normDayOfMonth = internal.clampEntity(dayLabel, internal.toInteger(day, dayLabel), 1, daysInMonth, overflow);
return internal.moveToDayOfMonthUnsafe(internal.createNativeDayOps(calendar), slots, normDayOfMonth);
}
function moveToDayOfWeek(slots, dayOfWeek, options) {
const overflow = internal.refineOverflowOptions(options), normDayOfWeek = internal.clampEntity(dayOfWeekLabel, internal.toInteger(dayOfWeek, dayOfWeekLabel), 1, 7, overflow);
return internal.moveByDays(slots, normDayOfWeek - internal.computeIsoDayOfWeek(slots));
}
function slotsWithWeekOfYear(slots, weekOfYear, options) {
const overflow = internal.refineOverflowOptions(options), calendarOps = internal.createNativeWeekOps(slots.calendar), [currentWeekOfYear, , weeksInYear] = calendarOps.weekParts(slots);
if (void 0 === currentWeekOfYear) {
throw new RangeError(internal.unsupportedWeekNumbers);
}
return moveByIsoWeeks(slots, internal.clampEntity(weekOfYearLabel, internal.toInteger(weekOfYear, weekOfYearLabel), 1, weeksInYear, overflow) - currentWeekOfYear);
}
function computeYearFloor(slots, calendarOps = internal.createNativeConvertOps(slots.calendar)) {
const [year0] = calendarOps.dateParts(slots);
return {
...internal.epochMilliToIso(calendarOps.epochMilli(year0)),
year: year0
};
}
function computeMonthFloor(slots, calendarOps = internal.createNativeConvertOps(slots.calendar)) {
const [year0, month0] = calendarOps.dateParts(slots);
return {
...internal.epochMilliToIso(calendarOps.epochMilli(year0, month0)),
year: year0,
month: month0
};
}
function computeIsoWeekFloor(slots) {
const dayOfWeek = internal.computeIsoDayOfWeek(slots);
return {
...internal.moveByDays(slots, 1 - dayOfWeek),
...internal.isoTimeFieldDefaults
};
}
function computeYearCeil(slots) {
return computeYearInterval(slots)[1];
}
function computeMonthCeil(slots) {
return computeMonthInterval(slots)[1];
}
function computeIsoWeekCeil(slots) {
return computeIsoWeekInterval(slots)[1];
}
function computeYearInterval(slots) {
const calendarOps = internal.createNativeConvertOps(slots.calendar), isoFields0 = computeYearFloor(slots), year1 = isoFields0.year + 1;
return [ isoFields0, internal.epochMilliToIso(calendarOps.epochMilli(year1)) ];
}
function computeMonthInterval(slots) {
const calendarOps = internal.createNativeConvertOps(slots.calendar), isoFields0 = computeMonthFloor(slots, calendarOps), [year1, month1] = calendarOps.monthAdd(isoFields0.year, isoFields0.month, 1);
return [ isoFields0, internal.epochMilliToIso(calendarOps.epochMilli(year1, month1)) ];
}
function computeIsoWeekInterval(slots) {
const isoFields0 = computeIsoWeekFloor(slots);
return [ isoFields0, moveByIsoWeeks(isoFields0, 1) ];
}
function roundDateTimeToInterval(computeInterval, slots, roundingMode) {
const [isoFields0, isoFields1] = computeInterval(slots), epochNano0 = internal.isoToEpochNano(isoFields0), epochNano1 = internal.isoToEpochNano(isoFields1), epochNano = internal.isoToEpochNano(slots), frac = internal.computeEpochNanoFrac(epochNano, epochNano0, epochNano1), isoFieldsRounded = internal.roundWithMode(frac, roundingMode) ? isoFields1 : isoFields0;
return {
...slots,
...isoFieldsRounded
};
}
function offsetNanoseconds(record) {
return internal.zonedEpochSlotsToIso(record, internal.queryNativeTimeZone).offsetNanoseconds;
}
function adaptDateFunc(dateFunc) {
return record => dateFunc(internal.zonedEpochSlotsToIso(record, internal.queryNativeTimeZone));
}
function moveByTimeUnit$1(nanoInUnit, record, units) {
const epochNano1 = internal.addBigNanos(record.epochNanoseconds, internal.numberToBigNano(internal.toStrictInteger(units), nanoInUnit));
return {
...record,
epochNanoseconds: internal.checkEpochNanoInBounds(epochNano1)
};
}
function rountToInterval(unit, computeInterval, record, options) {
const [, roundingMode] = internal.refineUnitRoundOptions(unit, options), timeZoneOps = internal.queryNativeTimeZone(record.timeZone), epochNano1 = internal.roundZonedEpochToInterval(computeInterval, timeZoneOps, record, roundingMode);
return {
...record,
epochNanoseconds: internal.checkEpochNanoInBounds(epochNano1)
};
}
function aligned$2(computeAlignment, nanoDelta = 0) {
return record => {
const timeZoneOps = internal.queryNativeTimeZone(record.timeZone), epochNano1 = internal.moveBigNano(internal.alignZonedEpoch(computeAlignment, timeZoneOps, record), nanoDelta);
return {
...record,
epochNanoseconds: internal.checkEpochNanoInBounds(epochNano1)
};
};
}
function zonedTransform(transformIso) {
return (record, ...args) => {
const timeZoneOps = internal.queryNativeTimeZone(record.timeZone), isoSlots = internal.zonedEpochSlotsToIso(record, timeZoneOps), transformedIsoSlots = transformIso(isoSlots, ...args), epochNano1 = internal.getSingleInstantFor(timeZoneOps, transformedIsoSlots);
return {
...record,
epochNanoseconds: internal.checkEpochNanoInBounds(epochNano1)
};
};
}
function addYears$1(record, years, options) {
return internal.checkIsoDateTimeInBounds(moveByYears(record, years, options));
}
function addMonths$1(record, months, options) {
return internal.checkIsoDateTimeInBounds(moveByMonths(record, months, options));
}
function addWeeks$1(record, weeks) {
return internal.checkIsoDateTimeInBounds(moveByIsoWeeks(record, weeks));
}
function addDays$1(record, days) {
return internal.checkIsoDateTimeInBounds(moveByDaysStrict(record, days));
}
function moveByTimeUnit(nanoInUnit, record, units) {
const epochNano0 = internal.isoToEpochNano(record), epochNano1 = internal.addBigNanos(epochNano0, internal.numberToBigNano(internal.toStrictInteger(units), nanoInUnit));
return internal.checkIsoDateTimeInBounds({
...record,
...internal.epochNanoToIso(epochNano1, 0)
});
}
function roundToInterval$1(unit, computeInterval, record, options) {
const [, roundingMode] = internal.refineUnitRoundOptions(unit, options);
return internal.createPlainDateTimeSlots(internal.checkIsoDateTimeInBounds(roundDateTimeToInterval(computeInterval, record, roundingMode)));
}
function aligned$1(computeAlignment, nanoDelta = 0) {
return record0 => {
let isoFields = computeAlignment(record0);
return nanoDelta && (isoFields = internal.epochNanoToIso(internal.isoToEpochNano(isoFields), nanoDelta)),
internal.createPlainDateTimeSlots(internal.checkIsoDateTimeInBounds({
...record0,
...isoFields
}));
};
}
function addYears(record, years, options) {
return internal.checkIsoDateInBounds(moveByYears(record, years, options));
}
function addMonths(record, months, options) {
return internal.checkIsoDateInBounds(moveByMonths(record, months, options));
}
function addWeeks(record, weeks) {
return internal.createPlainDateSlots(internal.checkIsoDateInBounds(moveByIsoWeeks(record, weeks)));
}
function addDays(record, days) {
return internal.createPlainDateSlots(internal.checkIsoDateInBounds(moveByDaysStrict(record, days)));
}
function roundToInterval(unit, computeInterval, record0, options) {
const [, roundingMode] = internal.refineUnitRoundOptions(unit, options), isoFields = roundDateTimeToInterval(computeInterval, record0, roundingMode);
return internal.createPlainDateSlots(internal.checkIsoDateInBounds({
...record0,
...isoFields
}));
}
function aligned(computeAlignment, dayDelta = 0) {
return record0 => {
const isoFields = internal.moveByDays(computeAlignment(record0), dayDelta);
return internal.createPlainDateSlots(internal.checkIsoDateInBounds({
...record0,
...isoFields
}));
};
}
var internal = require("./internal.cjs");
const create$7 = internal.constructInstantSlots, fromEpochSeconds = internal.epochSecToInstant, fromEpochMilliseconds = internal.epochMilliToInstant, fromEpochMicroseconds = internal.epochMicroToInstant, fromEpochNanoseconds = internal.epochNanoToInstant, fromString$7 = internal.parseInstant, epochSeconds$1 = internal.getEpochSec, epochMilliseconds$1 = internal.getEpochMilli, epochMicroseconds$1 = internal.getEpochMicro, epochNanoseconds$1 = internal.getEpochNano, add$6 = internal.bindArgs(internal.moveInstant, 0), subtract$6 = internal.bindArgs(internal.moveInstant, 1), until$5 = internal.bindArgs(internal.diffInstants, 0), since$5 = internal.bindArgs(internal.diffInstants, 1), round$4 = internal.roundInstant, equals$6 = internal.instantsEqual, compare$6 = internal.compareInstants, prepFormat$6 = internal.createFormatPrepper(internal.instantConfig, createFormatCache()), toString$7 = internal.bindArgs(internal.formatInstantIso, internal.refineTimeZoneId, internal.queryNativeTimeZone), diffZonedYears = internal.bindArgs(diffZonedLargeUnits, 9), diffZonedMonths = internal.bindArgs(diffZonedLargeUnits, 8), diffZonedWeeks = internal.bindArgs(diffZonedDayLikeUnits, 7, 7), diffZonedDays = internal.bindArgs(diffZonedDayLikeUnits, 6, 1), diffZonedTimeUnits = internal.bindArgs(diffTimeUnit, internal.extractEpochNano), diffPlainYears = internal.bindArgs(diffPlainLargeUnits, 9), diffPlainMonths = internal.bindArgs(diffPlainLargeUnits, 8), diffPlainWeeks = internal.bindArgs(diffPlainDayLikeUnit, internal.isoToEpochNano, 7, 7), diffPlainDays = internal.bindArgs(diffPlainDayLikeUnit, internal.isoToEpochNano, 6, 1), diffPlainTimeUnits = internal.bindArgs(diffTimeUnit, internal.isoToEpochNano), dayOfMonthLabel = "dayOfMonth", dayLabel = "day", dayOfWeekLabel = "dayOfWeek", weekOfYearLabel = "weekOfYear", computeHourFloor = internal.bindArgs(internal.clearIsoFields, 5), computeMinuteFloor = internal.bindArgs(internal.clearIsoFields, 4), computeSecFloor = internal.bindArgs(internal.clearIsoFields, 3), computeMilliFloor = internal.bindArgs(internal.clearIsoFields, 2), computeMicroFloor = internal.bindArgs(internal.clearIsoFields, 1), create$6 = internal.bindArgs(internal.constructZonedDateTimeSlots, internal.refineCalendarId, internal.refineTimeZoneId), fromString$6 = internal.parseZonedDateTime, getFields$5 = internal.memoize((record => {
const isoFields = internal.zonedEpochSlotsToIso(record, internal.queryNativeTimeZone), offsetString = internal.formatOffsetNano(isoFields.offsetNanoseconds);
return {
...computeDateFields(isoFields),
...internal.isoTimeFieldsToCal(isoFields),
offset: offsetString
};
}), WeakMap), getISOFields$5 = internal.bindArgs(internal.buildZonedIsoFields, internal.queryNativeTimeZone), calendarId$4 = getCalendarId, epochSeconds = internal.getEpochSec, epochMilliseconds = internal.getEpochMilli, epochMicroseconds = internal.getEpochMicro, epochNanoseconds = internal.getEpochNano, dayOfWeek$2 = adaptDateFunc(internal.computeIsoDayOfWeek), daysInWeek$2 = adaptDateFunc(internal.computeIsoDaysInWeek), weekOfYear$2 = adaptDateFunc(computeWeekOfYear), yearOfWeek$2 = adaptDateFunc(computeYearOfWeek), dayOfYear$2 = adaptDateFunc(computeDayOfYear), daysInMonth$3 = adaptDateFunc(computeDaysInMonth), daysInYear$3 = adaptDateFunc(computeDaysInYear), monthsInYear$3 = adaptDateFunc(computeMonthsInYear), inLeapYear$3 = adaptDateFunc(computeInLeapYear), hoursInDay = internal.bindArgs(internal.computeZonedHoursInDay, internal.queryNativeTimeZone), withPlainDate$1 = internal.bindArgs(internal.zonedDateTimeWithPlainDate, internal.queryNativeTimeZone), withPlainTime$1 = internal.bindArgs(internal.zonedDateTimeWithPlainTime, internal.queryNativeTimeZone), add$5 = internal.bindArgs(internal.moveZonedDateTime, internal.createNativeMoveOps, internal.queryNativeTimeZone, 0), subtract$5 = internal.bindArgs(internal.moveZonedDateTime, internal.createNativeMoveOps, internal.queryNativeTimeZone, 1), until$4 = internal.bindArgs(internal.diffZonedDateTimes, internal.createNativeDiffOps, internal.queryNativeTimeZone, 0), since$4 = internal.bindArgs(internal.diffZonedDateTimes, internal.createNativeDiffOps, internal.queryNativeTimeZone, 1), round$3 = internal.bindArgs(internal.roundZonedDateTime, internal.queryNativeTimeZone), startOfDay$1 = internal.bindArgs(internal.computeZonedStartOfDay, internal.queryNativeTimeZone), equals$5 = internal.zonedDateTimesEqual, compare$5 = internal.compareZonedDateTimes, toInstant = internal.zonedDateTimeToInstant, toPlainDateTime$2 = internal.bindArgs(internal.zonedDateTimeToPlainDateTime, internal.queryNativeTimeZone), toPlainDate$3 = internal.bindArgs(internal.zonedDateTimeToPlainDate, internal.queryNativeTimeZone), toPlainTime$1 = internal.bindArgs(internal.zonedDateTimeToPlainTime, internal.queryNativeTimeZone), prepFormat$5 = internal.createFormatPrepper(internal.zonedConfig, createFormatCache()), toString$6 = internal.bindArgs(internal.formatZonedDateTimeIso, internal.queryNativeTimeZone), withDayOfYear$2 = zonedTransform(moveToDayOfYear), withDayOfMonth$2 = zonedTransform(moveToDayOfMonth), withDayOfWeek$2 = zonedTransform(moveToDayOfWeek), withWeekOfYear$2 = zonedTransform(slotsWithWeekOfYear), addYears$2 = zonedTransform(moveByYears), addMonths$2 = zonedTransform(moveByMonths), addWeeks$2 = zonedTransform(moveByIsoWeeks), addDays$2 = zonedTransform(moveByDaysStrict), addHours$1 = internal.bindArgs(moveByTimeUnit$1, internal.nanoInHour), addMinutes$1 = internal.bindArgs(moveByTimeUnit$1, internal.nanoInMinute), addSeconds$1 = internal.bindArgs(moveByTimeUnit$1, internal.nanoInSec), addMilliseconds$1 = internal.bindArgs(moveByTimeUnit$1, internal.nanoInMilli), addMicroseconds$1 = internal.bindArgs(moveByTimeUnit$1, internal.nanoInMicro), addNanoseconds$1 = internal.bindArgs(moveByTimeUnit$1, 1), subtractYears$2 = reversedMove(addYears$2), subtractMonths$2 = reversedMove(addMonths$2), subtractWeeks$2 = reversedMove(addWeeks$2), subtractDays$2 = reversedMove(addDays$2), subtractHours$1 = reversedMove(addHours$1), subtractMinutes$1 = reversedMove(addMinutes$1), subtractSeconds$1 = reversedMove(addSeconds$1), subtractMilliseconds$1 = reversedMove(addMilliseconds$1), subtractMicroseconds$1 = reversedMove(addMicroseconds$1), subtractNanoseconds$1 = reversedMove(addNanoseconds$1), roundToYear$2 = internal.bindArgs(rountToInterval, 9, computeYearInterval), roundToMonth$2 = internal.bindArgs(rountToInterval, 8, computeMonthInterval), roundToWeek$2 = internal.bindArgs(rountToInterval, 7, computeIsoWeekInterval), startOfYear$2 = aligned$2(computeYearFloor), startOfMonth$2 = aligned$2(computeMonthFloor), startOfWeek$2 = aligned$2(computeIsoWeekFloor), startOfHour$1 = aligned$2(computeHourFloor), startOfMinute$1 = aligned$2(computeMinuteFloor), startOfSecond$1 = aligned$2(computeSecFloor), startOfMillisecond$1 = aligned$2(computeMilliFloor), startOfMicrosecond$1 = aligned$2(computeMicroFloor), endOfYear$2 = aligned$2(computeYearCeil, -1), endOfMonth$2 = aligned$2(computeMonthCeil, -1), endOfWeek$2 = aligned$2(computeIsoWeekCeil, -1), endOfDay$1 = aligned$2(internal.computeDayFloor, internal.nanoInUtcDay - 1), endOfHour$1 = aligned$2(computeHourFloor, internal.nanoInHour - 1), endOfMinute$1 = aligned$2(computeMinuteFloor, internal.nanoInMinute - 1), endOfSecond$1 = aligned$2(computeSecFloor, internal.nanoInSec - 1), endOfMillisecond$1 = aligned$2(computeMilliFloor, internal.nanoInMilli - 1), endOfMicrosecond$1 = aligned$2(computeMicroFloor, internal.nanoInMicro - 1), diffYears$2 = diffZonedYears, diffMonths$2 = diffZonedMonths, diffWeeks$2 = diffZonedWeeks, diffDays$2 = diffZonedDays,Line truncated
...computeDateFields(record),
...internal.isoTimeFieldsToCal(record)
})), WeakMap), getISOFields$4 = internal.identity, calendarId$3 = getCalendarId, dayOfWeek$1 = internal.computeIsoDayOfWeek, daysInWeek$1 = internal.computeIsoDaysInWeek, weekOfYear$1 = computeWeekOfYear, yearOfWeek$1 = computeYearOfWeek, dayOfYear$1 = computeDayOfYear, daysInMonth$2 = computeDaysInMonth, daysInYear$2 = computeDaysInYear, monthsInYear$2 = computeMonthsInYear, inLeapYear$2 = computeInLeapYear, withPlainDate = internal.plainDateTimeWithPlainDate, withPlainTime = internal.plainDateTimeWithPlainTime, add$4 = internal.bindArgs(internal.movePlainDateTime, internal.createNativeMoveOps, 0), subtract$4 = internal.bindArgs(internal.movePlainDateTime, internal.createNativeMoveOps, 1), until$3 = internal.bindArgs(internal.diffPlainDateTimes, internal.createNativeDiffOps, 0), since$3 = internal.bindArgs(internal.diffPlainDateTimes, internal.createNativeDiffOps, 1), round$2 = internal.roundPlainDateTime, equals$4 = internal.plainDateTimesEqual, compare$4 = internal.compareIsoDateTimeFields, toZonedDateTime$2 = internal.bindArgs(internal.plainDateTimeToZonedDateTime, internal.queryNativeTimeZone), toPlainDate$2 = internal.createPlainDateSlots, toPlainTime = internal.createPlainTimeSlots, prepFormat$4 = internal.createFormatPrepper(internal.dateTimeConfig, createFormatCache()), toString$5 = internal.formatPlainDateTimeIso, addHours = internal.bindArgs(moveByTimeUnit, internal.nanoInHour), addMinutes = internal.bindArgs(moveByTimeUnit, internal.nanoInMinute), addSeconds = internal.bindArgs(moveByTimeUnit, internal.nanoInSec), addMilliseconds = internal.bindArgs(moveByTimeUnit, internal.nanoInMilli), addMicroseconds = internal.bindArgs(moveByTimeUnit, internal.nanoInMicro), addNanoseconds = internal.bindArgs(moveByTimeUnit, 1), subtractYears$1 = reversedMove(addYears$1), subtractMonths$1 = reversedMove(addMonths$1), subtractWeeks$1 = reversedMove(addWeeks$1), subtractDays$1 = reversedMove(addDays$1), subtractHours = reversedMove(addHours), subtractMinutes = reversedMove(addMinutes), subtractSeconds = reversedMove(addSeconds), subtractMilliseconds = reversedMove(addMilliseconds), subtractMicroseconds = reversedMove(addMicroseconds), subtractNanoseconds = reversedMove(addNanoseconds), roundToYear$1 = internal.bindArgs(roundToInterval$1, 9, computeYearInterval), roundToMonth$1 = internal.bindArgs(roundToInterval$1, 8, computeMonthInterval), roundToWeek$1 = internal.bindArgs(roundToInterval$1, 7, computeIsoWeekInterval), startOfYear$1 = aligned$1(computeYearFloor), startOfMonth$1 = aligned$1(computeMonthFloor), startOfWeek$1 = aligned$1(computeIsoWeekFloor), startOfDay = aligned$1(internal.computeDayFloor), startOfHour = aligned$1(computeHourFloor), startOfMinute = aligned$1(computeMinuteFloor), startOfSecond = aligned$1(computeSecFloor), startOfMillisecond = aligned$1(computeMilliFloor), startOfMicrosecond = aligned$1(computeMicroFloor), endOfYear$1 = aligned$1(computeYearCeil, -1), endOfMonth$1 = aligned$1(computeMonthCeil, -1), endOfWeek$1 = aligned$1(computeIsoWeekCeil, -1), endOfDay = aligned$1(internal.computeDayFloor, internal.nanoInUtcDay - 1), endOfHour = aligned$1(computeHourFloor, internal.nanoInHour - 1), endOfMinute = aligned$1(computeMinuteFloor, internal.nanoInMinute - 1), endOfSecond = aligned$1(computeSecFloor, internal.nanoInSec - 1), endOfMillisecond = aligned$1(computeMilliFloor, internal.nanoInMilli - 1), endOfMicrosecond = aligned$1(computeMicroFloor, internal.nanoInMicro - 1), diffYears$1 = diffPlainYears, diffMonths$1 = diffPlainMonths, diffWeeks$1 = diffPlainWeeks, diffDays$1 = diffPlainDays, diffHours = internal.bindArgs(diffPlainTimeUnits, 5, internal.nanoInHour), diffMinutes = internal.bindArgs(diffPlainTimeUnits, 4, internal.nanoInMinute), diffSeconds = internal.bindArgs(diffPlainTimeUnits, 3, internal.nanoInSec), diffMilliseconds = internal.bindArgs(diffPlainTimeUnits, 2, internal.nanoInMilli), diffMicroseconds = internal.bindArgs(diffPlainTimeUnits, 1, internal.nanoInMicro), diffNanoseconds = internal.bindArgs(diffPlainTimeUnits, 0, 1), create$4 = internal.bindArgs(internal.constructPlainDateSlots, internal.refineCalendarId), fromString$4 = internal.parsePlainDate, getFields$3 = internal.memoize(computeDateFields, WeakMap), getISOFields$3 = internal.identity, calendarId$2 = getCalendarId, dayOfWeek = internal.computeIsoDayOfWeek, daysInWeek = internal.computeIsoDaysInWeek, weekOfYear = computeWeekOfYear, yearOfWeek = computeYearOfWeek, dayOfYear = computeDayOfYear, daysInMonth$1 = computeDaysInMonth, daysInYear$1 = computeDaysInYear, monthsInYear$1 = computeMonthsInYear, inLeapYear$1 = computeInLeapYear, add$3 = internal.bindArgs(internal.movePlainDate, internal.createNativeMoveOps, 0), subtract$3 = internal.bindArgs(internal.movePlainDate, internal.createNativeMoveOps, 1), until$2 = internal.bindArgs(internal.diffPlainDates, internal.createNativeDiffOps, 0), since$2 = internal.bindArgs(internal.diffPlainDates, internal.createNativeDiffOps, 1), equals$3 = internal.plainDatesEqual,Line truncated
const calendarOps = internal.createNativePartOps(slots.calendar), [year, month] = calendarOps.dateParts(slots), [era, eraYear] = calendarOps.eraParts(slots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month);
return {
era: era,
eraYear: eraYear,
year: year,
monthCode: internal.formatMonthCode(monthCodeNumber, isLeapMonth),
month: month
};
}), WeakMap), getISOFields$1 = internal.identity, calendarId$1 = getCalendarId, daysInMonth = computeDaysInMonth, daysInYear = computeDaysInYear, monthsInYear = computeMonthsInYear, inLeapYear = computeInLeapYear, add$1 = internal.bindArgs(internal.movePlainYearMonth, internal.createNativeYearMonthMoveOps, 0), subtract$1 = internal.bindArgs(internal.movePlainYearMonth, internal.createNativeYearMonthMoveOps, 1), until = internal.bindArgs(internal.diffPlainYearMonth, internal.createNativeYearMonthDiffOps, 0), since = internal.bindArgs(internal.diffPlainYearMonth, internal.createNativeYearMonthDiffOps, 1), equals$1 = internal.plainYearMonthsEqual, compare$1 = internal.compareIsoDateFields, prepFormat$1 = internal.createFormatPrepper(internal.yearMonthConfig, createFormatCache()), toString$2 = internal.formatPlainYearMonthIso, create$1 = internal.bindArgs(internal.constructPlainMonthDaySlots, internal.refineCalendarId), fromString$1 = internal.bindArgs(internal.parsePlainMonthDay, internal.createNativeMonthDayParseOps), getFields = internal.memoize((slots => {
const calendarOps = internal.createNativePartOps(slots.calendar), [year, month, day] = calendarOps.dateParts(slots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month);
return {
monthCode: internal.formatMonthCode(monthCodeNumber, isLeapMonth),
month: month,
day: day
};
}), WeakMap), getISOFields = internal.identity, calendarId = getCalendarId, equals = internal.plainMonthDaysEqual, prepFormat = internal.createFormatPrepper(internal.monthDayConfig, createFormatCache()), toString$1 = internal.formatPlainMonthDayIso, create = internal.constructDurationSlots, fromFields = internal.refineDurationBag, fromString = internal.parseDuration, blank = internal.getDurationBlank, withFields = internal.durationWithFields, negated = internal.negateDuration, abs = internal.absDuration, add = internal.bindArgs(internal.addDurations, internal.identity, internal.createNativeDiffOps, internal.queryNativeTimeZone, 0), subtract = internal.bindArgs(internal.addDurations, internal.identity, internal.createNativeDiffOps, internal.queryNativeTimeZone, 1), round = internal.bindArgs(internal.roundDuration, internal.identity, internal.createNativeDiffOps, internal.queryNativeTimeZone), total = internal.bindArgs(internal.totalDuration, internal.identity, internal.createNativeDiffOps, internal.queryNativeTimeZone), compare = internal.bindArgs(internal.compareDurations, internal.identity, internal.createNativeDiffOps, internal.queryNativeTimeZone), toString = internal.formatDurationIso, timeZoneId = internal.getCurrentTimeZoneId;
exports.abs = abs, exports.add = add$6, exports.add$1 = add$5, exports.add$2 = add$4,
exports.add$3 = add$3, exports.add$4 = add$2, exports.add$5 = add$1, exports.add$6 = add,
exports.addDays = addDays$2, exports.addDays$1 = addDays$1, exports.addDays$2 = addDays,
exports.addHours = addHours$1, exports.addHours$1 = addHours, exports.addMicroseconds = addMicroseconds$1,
exports.addMicroseconds$1 = addMicroseconds, exports.addMilliseconds = addMilliseconds$1,
exports.addMilliseconds$1 = addMilliseconds, exports.addMinutes = addMinutes$1,
exports.addMinutes$1 = addMinutes, exports.addMonths = addMonths$2, exports.addMonths$1 = addMonths$1,
exports.addMonths$2 = addMonths, exports.addNanoseconds = addNanoseconds$1, exports.addNanoseconds$1 = addNanoseconds,
exports.addSeconds = addSeconds$1, exports.addSeconds$1 = addSeconds, exports.addWeeks = addWeeks$2,
exports.addWeeks$1 = addWeeks$1, exports.addWeeks$2 = addWeeks, exports.addYears = addYears$2,
exports.addYears$1 = addYears$1, exports.addYears$2 = addYears, exports.blank = blank,
exports.calendarId = calendarId$4, exports.calendarId$1 = calendarId$3, exports.calendarId$2 = calendarId$2,
exports.calendarId$3 = calendarId$1, exports.calendarId$4 = calendarId, exports.compare = compare$6,
exports.compare$1 = compare$5, exports.compare$2 = compare$4, exports.compare$3 = compare$3,
exports.compare$4 = compare$2, exports.compare$5 = compare$1, exports.compare$6 = compare,
exports.create = create$7, exports.create$1 = create$6, exports.create$2 = create$5,
exports.create$3 = create$4, exports.create$4 = create$3, exports.create$5 = create$2,
exports.create$6 = create$1, exports.create$7 = create, exports.dayOfWeek = dayOfWeek$2,
exports.dayOfWeek$1 = dayOfWeek$1, exports.dayOfWeek$2 = dayOfWeek, exports.dayOfYear = dayOfYear$2,
exports.dayOfYear$1 = dayOfYear$1, exports.dayOfYear$2 = dayOfYear, exports.daysInMonth = daysInMonth$3,
exports.daysInMonth$1 = daysInMonth$2, exports.daysInMonth$2 = daysInMonth$1, exports.daysInMonth$3 = daysInMonth,
exports.daysInWeek = daysInWeek$2, exports.daysInWeek$1 = daysInWeek$1, exports.daysInWeek$2 = daysInWeek,
exports.daysInYear = daysInYear$3, exports.daysInYear$1 = daysInYear$2, exports.daysInYear$2 = daysInYear$1,
exports.daysInYear$3 = daysInYear, exports.diffDays = diffDays$2, exports.diffDays$1 = diffDays$1,
exports.diffDays$2 = diffDays, exports.diffHours = diffHours$1, exports.diffHours$1 = diffHours,
exports.diffMicroseconds = diffMicroseconds$1, exports.diffMicroseconds$1 = diffMicroseconds,
exports.diffMilliseconds = diffMilliseconds$1, exports.diffMilliseconds$1 = diffMilliseconds,
exports.diffMinutes = diffMinutes$1, exports.diffMinutes$1 = diffMinutes, exports.diffMonths = diffMonths$2,
exports.diffMonths$1 = diffMonths$1, exports.diffMonths$2 = diffMonths, exports.diffNanoseconds = diffNanoseconds$1,
exports.diffNanoseconds$1 = diffNanoseconds, exports.diffSeconds = diffSeconds$1,
exports.diffSeconds$1 = diffSeconds, exports.diffWeeks = diffWeeks$2, exports.diffWeeks$1 = diffWeeks$1,
exports.diffWeeks$2 = diffWeeks, exports.diffYears = diffYears$2, exports.diffYears$1 = diffYears$1,
exports.diffYears$2 = diffYears, exports.endOfDay = endOfDay$1, exports.endOfDay$1 = endOfDay,
exports.endOfHour = endOfHour$1, exports.endOfHour$1 = endOfHour, exports.endOfMicrosecond = endOfMicrosecond$1,
exports.endOfMicrosecond$1 = endOfMicrosecond, exports.endOfMillisecond = endOfMillisecond$1,
exports.endOfMillisecond$1 = endOfMillisecond, exports.endOfMinute = endOfMinute$1,
exports.endOfMinute$1 = endOfMinute, exports.endOfMonth = endOfMonth$2, exports.endOfMonth$1 = endOfMonth$1,
exports.endOfMonth$2 = endOfMonth, exports.endOfSecond = endOfSecond$1, exports.endOfSecond$1 = endOfSecond,
exports.endOfWeek = endOfWeek$2, exports.endOfWeek$1 = endOfWeek$1, exports.endOfWeek$2 = endOfWeek,
exports.endOfYear = endOfYear$2, exports.endOfYear$1 = endOfYear$1, exports.endOfYear$2 = endOfYear,
exports.epochMicroseconds = epochMicroseconds$1, exports.epochMicroseconds$1 = epochMicroseconds,
exports.epochMilliseconds = epochMilliseconds$1, exports.epochMilliseconds$1 = epochMilliseconds,
exports.epochNanoseconds = epochNanoseconds$1, exports.epochNanoseconds$1 = epochNanoseconds,
exports.epochSeconds = epochSeconds$1, exports.epochSeconds$1 = epochSeconds, exports.equals = equals$6,
exports.equals$1 = equals$5, exports.equals$2 = equals$4, exports.equals$3 = equals$3,
exports.equals$4 = equals$2, exports.equals$5 = equals$1, exports.equals$6 = equals,
exports.fromEpochMicroseconds = fromEpochMicroseconds, exports.fromEpochMilliseconds = fromEpochMilliseconds,
exports.fromEpochNanoseconds = fromEpochNanoseconds, exports.fromEpochSeconds = fromEpochSeconds,
exports.fromFields = (fields, options) => {
const calendarId = getCalendarIdFromBag(fields);
return internal.refineZonedDateTimeBag(internal.refineTimeZoneId, internal.queryNativeTimeZone, internal.createNativeDateRefineOps(calendarId), calendarId, fields, options);
}, exports.fromFields$1 = (fields, options) => internal.refinePlainDateTimeBag(internal.createNativeDateRefineOps(getCalendarIdFromBag(fields)), fields, options),
exports.fromFields$2 = (fields, options) => internal.refinePlainDateBag(internal.createNativeDateRefineOps(getCalendarIdFromBag(fields)), fields, options),
exports.fromFields$3 = fromFields$3, exports.fromFields$4 = (fields, options) => internal.refinePlainYearMonthBag(internal.createNativeYearMonthRefineOps(getCalendarIdFromBag(fields)), fields, options),
exports.fromFields$5 = (fields, options) => {
const calendarMaybe = extractCalendarIdFromBag(fields), calendar = calendarMaybe || internal.isoCalendarId;
return internal.refinePlainMonthDayBag(internal.createNativeMonthDayRefineOps(calendar), !calendarMaybe, fields, options);
}, exports.fromFields$6 = fromFields, exports.fromString = fromString$7, exports.fromString$1 = fromString$6,
exports.fromString$2 = fromString$5, exports.fromString$3 = fromString$4, exports.fromString$4 = fromString$3,
exports.fromString$5 = fromString$2, exports.fromString$6 = fromString$1, exports.fromString$7 = fromString,
exports.getFields = getFields$5, exports.getFields$1 = getFields$4, exports.getFields$2 = getFields$3,
exports.getFields$3 = getFields$2, exports.getFields$4 = getFields$1, exports.getFields$5 = getFields,
exports.getISOFields = getISOFields$5, exports.getISOFields$1 = getISOFields$4,
exports.getISOFields$2 = getISOFields$3, exports.getISOFields$3 = getISOFields$2,
exports.getISOFields$4 = getISOFields$1, exports.getISOFields$5 = getISOFields,
exports.hoursInDay = hoursInDay, exports.inLeapYear = inLeapYear$3, exports.inLeapYear$1 = inLeapYear$2,
exports.inLeapYear$2 = inLeapYear$1, exports.inLeapYear$3 = inLeapYear, exports.instant = () => internal.createInstantSlots(internal.getCurrentEpochNano()),
exports.isInstance = record => Boolean(record) && record.branding === internal.InstantBranding,
exports.isInstance$1 = record => Boolean(record) && record.branding === internal.ZonedDateTimeBranding,
exports.isInstance$2 = record => Boolean(record) && record.branding === internal.PlainDateTimeBranding,
exports.isInstance$3 = record => Boolean(record) && record.branding === internal.PlainDateBranding,
exports.isInstance$4 = record => Boolean(record) && record.branding === internal.PlainTimeBranding,
exports.isInstance$5 = record => Boolean(record) && record.branding === internal.PlainYearMonthBranding,
exports.isInstance$6 = record => Boolean(record) && record.branding === internal.PlainMonthDayBranding,
exports.isInstance$7 = record => Boolean(record) && record.branding === internal.DurationBranding,
exports.monthsInYear = monthsInYear$3, exports.monthsInYear$1 = monthsInYear$2,
exports.monthsInYear$2 = monthsInYear$1, exports.monthsInYear$3 = monthsInYear,
exports.negated = negated, exports.offset = record => internal.formatOffsetNano(offsetNanoseconds(record)),
exports.offsetNanoseconds = offsetNanoseconds, exports.plainDate = (calendar, timeZone = internal.getCurrentTimeZoneId()) => internal.createPlainDateSlots(internal.getCurrentIsoDateTime(internal.queryNativeTimeZone(internal.refineTimeZoneId(timeZone))), internal.refineCalendarId(calendar)),
exports.plainDateISO = (timeZone = internal.getCurrentTimeZoneId()) => internal.createPlainDateSlots(internal.getCurrentIsoDateTime(internal.queryNativeTimeZone(internal.refineTimeZoneId(timeZone))), internal.isoCalendarId),
exports.plainDateTime = (calendar, timeZone = internal.getCurrentTimeZoneId()) => internal.createPlainDateTimeSlots(internal.getCurrentIsoDateTime(internal.queryNativeTimeZone(internal.refineTimeZoneId(timeZone))), internal.refineCalendarId(calendar)),
exports.plainDateTimeISO = (timeZone = internal.getCurrentTimeZoneId()) => internal.createPlainDateTimeSlots(internal.getCurrentIsoDateTime(internal.queryNativeTimeZone(internal.refineTimeZoneId(timeZone))), internal.isoCalendarId),
exports.plainTimeISO = (timeZone = internal.getCurrentTimeZoneId()) => internal.createPlainTimeSlots(internal.getCurrentIsoDateTime(internal.queryNativeTimeZone(internal.refineTimeZoneId(timeZone)))),
exports.rangeToLocaleString = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$6(locales, options, record0, record1);
return format.formatRange(epochMilli0, epochMilli1);
}, exports.rangeToLocaleString$1 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$5(locales, options, record0, record1);
return format.formatRange(epochMilli0, epochMilli1);
}, exports.rangeToLocaleString$2 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$4(locales, options, record0, record1);
return format.formatRange(epochMilli0, epochMilli1);
}, exports.rangeToLocaleString$3 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$3(locales, options, record0, record1);
return format.formatRange(epochMilli0, epochMilli1);
}, exports.rangeToLocaleString$4 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$2(locales, options, record0, record1);
return format.formatRange(epochMilli0, epochMilli1);
}, exports.rangeToLocaleString$5 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$1(locales, options, record0, record1);
return format.formatRange(epochMilli0, epochMilli1);
}, exports.rangeToLocaleString$6 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat(locales, options, record0, record1);
return format.formatRange(epochMilli0, epochMilli1);
}, exports.rangeToLocaleStringParts = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$6(locales, options, record0, record1);
return format.formatRangeToParts(epochMilli0, epochMilli1);
}, exports.rangeToLocaleStringParts$1 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$5(locales, options, record0, record1);
return format.formatRangeToParts(epochMilli0, epochMilli1);
}, exports.rangeToLocaleStringParts$2 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$4(locales, options, record0, record1);
return format.formatRangeToParts(epochMilli0, epochMilli1);
}, exports.rangeToLocaleStringParts$3 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$3(locales, options, record0, record1);
return format.formatRangeToParts(epochMilli0, epochMilli1);
}, exports.rangeToLocaleStringParts$4 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$2(locales, options, record0, record1);
return format.formatRangeToParts(epochMilli0, epochMilli1);
}, exports.rangeToLocaleStringParts$5 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat$1(locales, options, record0, record1);
return format.formatRangeToParts(epochMilli0, epochMilli1);
}, exports.rangeToLocaleStringParts$6 = (record0, record1, locales, options) => {
const [format, epochMilli0, epochMilli1] = prepFormat(locales, options, record0, record1);
return format.formatRangeToParts(epochMilli0, epochMilli1);
}, exports.round = round$4, exports.round$1 = round$3, exports.round$2 = round$2,
exports.round$3 = round$1, exports.round$4 = round, exports.roundToMonth = roundToMonth$2,
exports.roundToMonth$1 = roundToMonth$1, exports.roundToMonth$2 = roundToMonth,
exports.roundToWeek = roundToWeek$2, exports.roundToWeek$1 = roundToWeek$1, exports.roundToWeek$2 = roundToWeek,
exports.roundToYear = roundToYear$2, exports.roundToYear$1 = roundToYear$1, exports.roundToYear$2 = roundToYear,
exports.since = since$5, exports.since$1 = since$4, exports.since$2 = since$3, exports.since$3 = since$2,
exports.since$4 = since$1, exports.since$5 = since, exports.startOfDay = startOfDay$1,
exports.startOfDay$1 = startOfDay, exports.startOfHour = startOfHour$1, exports.startOfHour$1 = startOfHour,
exports.startOfMicrosecond = startOfMicrosecond$1, exports.startOfMicrosecond$1 = startOfMicrosecond,
exports.startOfMillisecond = startOfMillisecond$1, exports.startOfMillisecond$1 = startOfMillisecond,
exports.startOfMinute = startOfMinute$1, exports.startOfMinute$1 = startOfMinute,
exports.startOfMonth = startOfMonth$2, exports.startOfMonth$1 = startOfMonth$1,
exports.startOfMonth$2 = startOfMonth, exports.startOfSecond = startOfSecond$1,
exports.startOfSecond$1 = startOfSecond, exports.startOfWeek = startOfWeek$2, exports.startOfWeek$1 = startOfWeek$1,
exports.startOfWeek$2 = startOfWeek, exports.startOfYear = startOfYear$2, exports.startOfYear$1 = startOfYear$1,
exports.startOfYear$2 = startOfYear, exports.subtract = subtract$6, exports.subtract$1 = subtract$5,
exports.subtract$2 = subtract$4, exports.subtract$3 = subtract$3, exports.subtract$4 = subtract$2,
exports.subtract$5 = subtract$1, exports.subtract$6 = subtract, exports.subtractDays = subtractDays$2,
exports.subtractDays$1 = subtractDays$1, exports.subtractDays$2 = subtractDays,
exports.subtractHours = subtractHours$1, exports.subtractHours$1 = subtractHours,
exports.subtractMicroseconds = subtractMicroseconds$1, exports.subtractMicroseconds$1 = subtractMicroseconds,
exports.subtractMilliseconds = subtractMilliseconds$1, exports.subtractMilliseconds$1 = subtractMilliseconds,
exports.subtractMinutes = subtractMinutes$1, exports.subtractMinutes$1 = subtractMinutes,
exports.subtractMonths = subtractMonths$2, exports.subtractMonths$1 = subtractMonths$1,
exports.subtractMonths$2 = subtractMonths, exports.subtractNanoseconds = subtractNanoseconds$1,
exports.subtractNanoseconds$1 = subtractNanoseconds, exports.subtractSeconds = subtractSeconds$1,
exports.subtractSeconds$1 = subtractSeconds, exports.subtractWeeks = subtractWeeks$2,
exports.subtractWeeks$1 = subtractWeeks$1, exports.subtractWeeks$2 = subtractWeeks,
exports.subtractYears = subtractYears$2, exports.subtractYears$1 = subtractYears$1,
exports.subtractYears$2 = subtractYears, exports.timeZoneId = record => record.timeZone,
exports.timeZoneId$1 = timeZoneId, exports.toInstant = toInstant, exports.toLocaleString = (record, locales, options) => {
const [format, epochMilli] = prepFormat$6(locales, options, record);
return format.format(epochMilli);
}, exports.toLocaleString$1 = (record, locales, options) => {
const [format, epochMilli] = prepFormat$5(locales, options, record);
return format.format(epochMilli);
}, exports.toLocaleString$2 = (record, locales, options) => {
const [format, epochMilli] = prepFormat$4(locales, options, record);
return format.format(epochMilli);
}, exports.toLocaleString$3 = (record, locales, options) => {
const [format, epochMilli] = prepFormat$3(locales, options, record);
return format.format(epochMilli);
}, exports.toLocaleString$4 = (record, locales, options) => {
const [format, epochMilli] = prepFormat$2(locales, options, record);
return format.format(epochMilli);
}, exports.toLocaleString$5 = (record, locales, options) => {
const [format, epochMilli] = prepFormat$1(locales, options, record);
return format.format(epochMilli);
}, exports.toLocaleString$6 = (record, locales, options) => {
const [format, epochMilli] = prepFormat(locales, options, record);
return format.format(epochMilli);
}, exports.toLocaleString$7 = (record, locales, options) => Intl.DurationFormat ? new Intl.DurationFormat(locales, options).format(record) : internal.formatDurationIso(record),
exports.toLocaleStringParts = (record, locales, options) => {
const [format, epochMilli] = prepFormat$6(locales, options, record);
return format.formatToParts(epochMilli);
}, exports.toLocaleStringParts$1 = (record, locales, options) => {
const [format, epochMilli] = prepFormat$5(locales, options, record);
return format.formatToParts(epochMilli);
}, exports.toLocaleStringParts$2 = (record, locales, options) => {
const [format, epochMilli] = prepFormat$4(locales, options, record);
return format.formatToParts(epochMilli);
}, exports.toLocaleStringParts$3 = (record, locales, options) => {
const [format, epochMilli] = prepFormat$3(locales, options, record);
return format.formatToParts(epochMilli);
}, exports.toLocaleStringParts$4 = (record, locales, options) => {
const [format, epochMilli] = prepFormat$2(locales, options, record);
return format.formatToParts(epochMilli);
}, exports.toLocaleStringParts$5 = (record, locales, options) => {
const [format, epochMilli] = prepFormat$1(locales, options, record);
return format.formatToParts(epochMilli);
}, exports.toLocaleStringParts$6 = (record, locales, options) => {
const [format, epochMilli] = prepFormat(locales, options, record);
return format.formatToParts(epochMilli);
}, exports.toPlainDate = toPlainDate$3, exports.toPlainDate$1 = toPlainDate$2, exports.toPlainDate$2 = (record, fields) => internal.plainYearMonthToPlainDate(internal.createNativeDateModOps, record, getFields$1(record), fields),
exports.toPlainDate$3 = (record, fields) => internal.plainMonthDayToPlainDate(internal.createNativeDateModOps, record, getFields(record), fields),
exports.toPlainDateTime = toPlainDateTime$2, exports.toPlainDateTime$1 = toPlainDateTime$1,
exports.toPlainDateTime$2 = toPlainDateTime, exports.toPlainMonthDay = record => internal.zonedDateTimeToPlainMonthDay(internal.createNativeMonthDayRefineOps, record, getFields$5(record)),
exports.toPlainMonthDay$1 = record => internal.plainDateTimeToPlainMonthDay(internal.createNativeMonthDayRefineOps, record, getFields$4(record)),
exports.toPlainMonthDay$2 = record => internal.plainDateToPlainMonthDay(internal.createNativeMonthDayRefineOps, record, getFields$3(record)),
exports.toPlainTime = toPlainTime$1, exports.toPlainTime$1 = toPlainTime, exports.toPlainYearMonth = record => internal.zonedDateTimeToPlainYearMonth(internal.createNativeYearMonthRefineOps, record, getFields$5(record)),
exports.toPlainYearMonth$1 = record => internal.plainDateTimeToPlainYearMonth(internal.createNativeYearMonthRefineOps, record, getFields$4(record)),
exports.toPlainYearMonth$2 = record => internal.plainDateToPlainYearMonth(internal.createNativeYearMonthRefineOps, record, getFields$3(record)),
exports.toString = toString$7, exports.toString$1 = toString$6, exports.toString$2 = toString$5,
exports.toString$3 = toString$4, exports.toString$4 = toString$3, exports.toString$5 = toString$2,
exports.toString$6 = toString$1, exports.toString$7 = toString, exports.toZonedDateTime = (record, options) => {
const refinedObj = internal.requireObjectLike(options);
return internal.instantToZonedDateTime(record, internal.refineTimeZoneId(refinedObj.timeZone), internal.refineCalendarId(refinedObj.calendar));
}, exports.toZonedDateTime$1 = toZonedDateTime$2, exports.toZonedDateTime$2 = (record, options) => {
const optionsObj = "string" == typeof options ? {
timeZone: options
} : options;
return internal.plainDateToZonedDateTime(internal.refineTimeZoneId, internal.identity, internal.queryNativeTimeZone, record, optionsObj);
}, exports.toZonedDateTime$3 = toZonedDateTime, exports.toZonedDateTimeISO = (record, timeZone) => internal.instantToZonedDateTime(record, internal.refineTimeZoneId(timeZone)),
exports.total = total, exports.until = until$5, exports.until$1 = until$4, exports.until$2 = until$3,
exports.until$3 = until$2, exports.until$4 = until$1, exports.until$5 = until, exports.weekOfYear = weekOfYear$2,
exports.weekOfYear$1 = weekOfYear$1, exports.weekOfYear$2 = weekOfYear, exports.withCalendar = (record, calendar) => internal.slotsWithCalendarId(record, internal.refineCalendarId(calendar)),
exports.withCalendar$1 = (record, calendar) => internal.slotsWithCalendarId(record, internal.refineCalendarId(calendar)),
exports.withCalendar$2 = (record, calendar) => internal.slotsWithCalendarId(record, internal.refineCalendarId(calendar)),
exports.withDayOfMonth = withDayOfMonth$2, exports.withDayOfMonth$1 = (record, dayOfMonth, options) => internal.checkIsoDateTimeInBounds(moveToDayOfMonth(record, dayOfMonth, options)),
exports.withDayOfMonth$2 = (record, dayOfMonth, options) => internal.createPlainDateSlots(internal.checkIsoDateInBounds(moveToDayOfMonth(record, dayOfMonth, options))),
exports.withDayOfWeek = withDayOfWeek$2, exports.withDayOfWeek$1 = (record, dayOfWeek, options) => internal.checkIsoDateTimeInBounds(moveToDayOfWeek(record, dayOfWeek, options)),
exports.withDayOfWeek$2 = (record, dayOfWeek, options) => internal.createPlainDateSlots(internal.checkIsoDateInBounds(moveToDayOfWeek(record, dayOfWeek, options))),
exports.withDayOfYear = withDayOfYear$2, exports.withDayOfYear$1 = (record, dayOfYear, options) => internal.checkIsoDateTimeInBounds(moveToDayOfYear(record, dayOfYear, options)),
exports.withDayOfYear$2 = (record, dayOfYear, options) => internal.createPlainDateSlots(internal.checkIsoDateInBounds(moveToDayOfYear(record, dayOfYear, options))),
exports.withFields = (record, fields, options) => internal.zonedDateTimeWithFields(internal.createNativeDateModOps, internal.queryNativeTimeZone, record, fields, options),
exports.withFields$1 = (record, fields, options) => internal.plainDateTimeWithFields(internal.createNativeDateModOps, record, fields, options),
exports.withFields$2 = (record, fields, options) => internal.plainDateWithFields(internal.createNativeDateModOps, record, fields, options),
exports.withFields$3 = (record, fields, options) => internal.plainTimeWithFields(getFields$2(record), fields, options),
exports.withFields$4 = (record, fields, options) => internal.plainYearMonthWithFields(internal.createNativeYearMonthModOps, record, fields, options),
exports.withFields$5 = (record, fields, options) => internal.plainMonthDayWithFields(internal.createNativeMonthDayModOps, record, fields, options),
exports.withFields$6 = withFields, exports.withPlainDate = withPlainDate$1, exports.withPlainDate$1 = withPlainDate,
exports.withPlainTime = withPlainTime$1, exports.withPlainTime$1 = withPlainTime,
exports.withTimeZone = (record, timeZone) => internal.slotsWithTimeZoneId(record, internal.refineTimeZoneId(timeZone)),
exports.withWeekOfYear = withWeekOfYear$2, exports.withWeekOfYear$1 = (record, weekOfYear, options) => internal.checkIsoDateTimeInBounds(slotsWithWeekOfYear(record, weekOfYear, options)),
exports.withWeekOfYear$2 = (record, weekOfYear, options) => internal.createPlainDateSlots(internal.checkIsoDateInBounds(slotsWithWeekOfYear(record, weekOfYear, options))),
exports.yearOfWeek = yearOfWeek$2, exports.yearOfWeek$1 = yearOfWeek$1, exports.yearOfWeek$2 = yearOfWeek,
exports.zonedDateTime = (calendar, timeZone = internal.getCurrentTimeZoneId()) => internal.createZonedDateTimeSlots(internal.getCurrentEpochNano(), internal.refineTimeZoneId(timeZone), internal.refineCalendarId(calendar)),
exports.zonedDateTimeISO = (timeZone = internal.getCurrentTimeZoneId()) => internal.createZonedDateTimeSlots(internal.getCurrentEpochNano(), internal.refineTimeZoneId(timeZone), internal.isoCalendarId);
@@ -0,0 +1,744 @@
function createFormatCache() {
const e = on((e => {
const n = new Map;
return (t, a, o) => {
const r = [].concat(t || [], a || []).join();
let s = n.get(r);
return s || (s = an(t, a, e, o, 0), n.set(r, s)), s;
};
}), WeakMap);
return (n, t, a, o) => e(a)(n, t, o);
}
function isInstance$7(e) {
return Boolean(e) && e.branding === Re;
}
function toZonedDateTime$3(e, n) {
const t = oa(n);
return Je(e, Me(t.timeZone), Zt(t.calendar));
}
function toZonedDateTimeISO(e, n) {
return Je(e, Me(n));
}
function toLocaleString$7(e, n, t) {
const [a, o] = Jo(n, t, e);
return a.format(o);
}
function toLocaleStringParts$6(e, n, t) {
const [a, o] = Jo(n, t, e);
return a.formatToParts(o);
}
function rangeToLocaleString$6(e, n, t, a) {
const [o, r, s] = Jo(t, a, e, n);
return o.formatRange(r, s);
}
function rangeToLocaleStringParts$6(e, n, t, a) {
const [o, r, s] = Jo(t, a, e, n);
return o.formatRangeToParts(r, s);
}
function getCalendarId(e) {
return e.calendar;
}
function getCalendarIdFromBag(e) {
return extractCalendarIdFromBag(e) || l;
}
function extractCalendarIdFromBag(e) {
const {calendar: n} = e;
if (void 0 !== n) {
return Zt(n);
}
}
function computeDateFields(e) {
const n = ra(e.calendar), [t, a, o] = n.u(e), [r, s] = n.$(e), [i, c] = n.m(t, a);
return {
era: r,
eraYear: s,
year: t,
monthCode: sa(i, c),
month: a,
day: o
};
}
function computeYearMonthFields(e) {
const n = ra(e.calendar), [t, a] = n.u(e), [o, r] = n.$(e), [s, i] = n.m(t, a);
return {
era: o,
eraYear: r,
year: t,
monthCode: sa(s, i),
month: a
};
}
function computeMonthDayFields(e) {
const n = ra(e.calendar), [t, a, o] = n.u(e), [r, s] = n.m(t, a);
return {
monthCode: sa(r, s),
month: a,
day: o
};
}
function computeInLeapYear(e) {
return ia(e.calendar).inLeapYear(e);
}
function computeMonthsInYear(e) {
return ca(e.calendar).monthsInYear(e);
}
function computeDaysInMonth(e) {
return da(e.calendar).daysInMonth(e);
}
function computeDaysInYear(e) {
return ua(e.calendar).daysInYear(e);
}
function computeDayOfYear(e) {
return la(e.calendar).dayOfYear(e);
}
function computeWeekOfYear(e) {
return $a(e.calendar).weekOfYear(e);
}
function computeYearOfWeek(e) {
return $a(e.calendar).yearOfWeek(e);
}
function diffZonedLargeUnits(e, n, t, a) {
const o = ga(n.timeZone, t.timeZone), r = L(o), s = ha(n.calendar, t.calendar), i = Ia(s);
return diffDateUnits(fa, gt(Sa, r), gt(Fa, r), ((n, t) => i.h(n, t, e)), e, i, n, t, a);
}
function diffPlainLargeUnits(e, n, t, a) {
const o = ha(n.calendar, t.calendar), r = Ia(o);
return diffDateUnits(ma, identityMarkersToIsoFields, ka, ((n, t) => r.h(n, t, e)), e, r, n, t, a);
}
function identityMarkersToIsoFields(e, n) {
return [ e, n ];
}
function diffDateUnits(e, n, t, a, o, r, s, i, c) {
const [d, u] = Ma(o, c), l = e(s), $ = e(i), f = pa($, l);
if (!f) {
return 0;
}
const [m, g] = n(s, i, f), h = a(m, g);
let I = ya(h, $, o, r, s, e, t);
return d && (I = Da(I, d, u)), I;
}
function diffZonedDayLikeUnits(e, n, t, a, o) {
const [r, s] = Ma(e, o), i = ga(t.timeZone, a.timeZone), c = L(i), d = pa(a.epochNanoseconds, t.epochNanoseconds), [u, l, $] = Sa(c, t, a, d), f = Ta(va(ma(u), ma(l)), $);
let m = Oa(f) / n;
return r && (m = Da(m, r, s)), m;
}
function diffPlainDayLikeUnit(e, n, t, a, o, r) {
const [s, i] = Ma(n, r), c = va(e(a), e(o));
let d = Oa(c) / t;
return s && (d = Da(d, s, i)), d;
}
function diffTimeUnit(e, n, t, a, o, r) {
const [s, i] = Ma(n, r);
let c = va(e(a), e(o));
return s && (c = Ya(c, t * s, i)), La(c, t, !s);
}
function reversedMove(e) {
return (n, t, a) => e(n, -t, a);
}
function moveByYears(e, n, t) {
const a = dt(t);
if (!n) {
return e;
}
const o = Wa(e.calendar), r = Pa(wa(o, e, Ba(n), 0, a)), s = nn(Ca, r);
return {
...e,
...s
};
}
function moveByMonths(e, n, t) {
const a = dt(t);
if (!n) {
return e;
}
const o = Wa(e.calendar), r = Pa(wa(o, e, 0, Ba(n), a)), s = nn(Ca, r);
return {
...e,
...s
};
}
function moveByIsoWeeks(e, n) {
return Ua(e, 7 * Ba(n));
}
function moveByDaysStrict(e, n) {
return Ua(e, Ba(n));
}
function moveToDayOfYear(e, n, t) {
const a = dt(t), {calendar: o} = e, r = ua(o).daysInYear(e), s = ba(sr, Za(n, sr), 1, r, a), i = la(o).dayOfYear(e);
return Ua(e, s - i);
}
function moveToDayOfMonth(e, n, t) {
const a = dt(t), {calendar: o} = e, r = da(o).daysInMonth(e), s = ba(ir, Za(n, ir), 1, r, a);
return Na(za(o), e, s);
}
function moveToDayOfWeek(e, n, t) {
const a = dt(t), o = ba(cr, Za(n, cr), 1, 7, a);
return Ua(e, o - Ha(e));
}
function slotsWithWeekOfYear(e, n, t) {
const a = dt(t), o = $a(e.calendar), [r, , s] = o.I(e);
if (void 0 === r) {
throw new RangeError(qa);
}
return moveByIsoWeeks(e, ba(dr, Za(n, dr), 1, s, a) - r);
}
function computeYearFloor(e, n = xa(e.calendar)) {
const [t] = n.u(e);
return {
...Pa(n.M(t)),
year: t
};
}
function computeMonthFloor(e, n = xa(e.calendar)) {
const [t, a] = n.u(e);
return {
...Pa(n.M(t, a)),
year: t,
month: a
};
}
function computeIsoWeekFloor(e) {
const n = Ha(e);
return {
...Ua(e, 1 - n),
...At
};
}
function computeYearCeil(e) {
return computeYearInterval(e)[1];
}
function computeMonthCeil(e) {
return computeMonthInterval(e)[1];
}
function computeIsoWeekCeil(e) {
return computeIsoWeekInterval(e)[1];
}
function computeYearInterval(e) {
const n = xa(e.calendar), t = computeYearFloor(e), a = t.year + 1;
return [ t, Pa(n.M(a)) ];
}
function computeMonthInterval(e) {
const n = xa(e.calendar), t = computeMonthFloor(e, n), [a, o] = n.p(t.year, t.month, 1);
return [ t, Pa(n.M(a, o)) ];
}
function computeIsoWeekInterval(e) {
const n = computeIsoWeekFloor(e);
return [ n, moveByIsoWeeks(n, 1) ];
}
function roundDateTimeToInterval(e, n, t) {
const [a, o] = e(n), r = ma(a), s = ma(o), i = ma(n), c = ja(i, r, s), d = Ea(c, t) ? o : a;
return {
...n,
...d
};
}
function fromFields$6(e, n) {
const t = getCalendarIdFromBag(e);
return Ae(Me, L, Aa(t), t, e, n);
}
function isInstance$6(e) {
return Boolean(e) && e.branding === _;
}
function timeZoneId$1(e) {
return e.timeZone;
}
function offsetNanoseconds(e) {
return he(e, L).offsetNanoseconds;
}
function offset(e) {
return Se(offsetNanoseconds(e));
}
function withFields$6(e, n, t) {
return De(mo, L, e, n, t);
}
function withCalendar$2(e, n) {
return Ot(e, Zt(n));
}
function withTimeZone(e, n) {
return ge(e, Me(n));
}
function toPlainYearMonth$2(e) {
return Qa(Va, e, Ir(e));
}
function toPlainMonthDay$2(e) {
return Xa(_a, e, Ir(e));
}
function toLocaleString$6(e, n, t) {
const [a, o] = Jr(n, t, e);
return a.format(o);
}
function toLocaleStringParts$5(e, n, t) {
const [a, o] = Jr(n, t, e);
return a.formatToParts(o);
}
function rangeToLocaleString$5(e, n, t, a) {
const [o, r, s] = Jr(t, a, e, n);
return o.formatRange(r, s);
}
function rangeToLocaleStringParts$5(e, n, t, a) {
const [o, r, s] = Jr(t, a, e, n);
return o.formatRangeToParts(r, s);
}
function adaptDateFunc(e) {
return n => e(he(n, L));
}
function moveByTimeUnit$1(e, n, t) {
const a = so(n.epochNanoseconds, Ge(Ba(t), e));
return {
...n,
epochNanoseconds: io(a)
};
}
function rountToInterval(e, n, t, a) {
const [, o] = co(e, a), r = L(t.timeZone), s = uo(n, r, t, o);
return {
...t,
epochNanoseconds: io(s)
};
}
function aligned$2(e, n = 0) {
return t => {
const a = L(t.timeZone), o = Ta(lo(e, a, t), n);
return {
...t,
epochNanoseconds: io(o)
};
};
}
function zonedTransform(e) {
return (n, ...t) => {
const a = L(n.timeZone), o = he(n, a), r = e(o, ...t), s = $o(a, r);
return {
...n,
epochNanoseconds: io(s)
};
};
}
function fromFields$5(e, n) {
return Nt(Aa(getCalendarIdFromBag(e)), e, n);
}
function isInstance$5(e) {
return Boolean(e) && e.branding === x;
}
function withFields$5(e, n, t) {
return Pt(mo, e, n, t);
}
function withCalendar$1(e, n) {
return Ot(e, Zt(n));
}
function toPlainYearMonth$1(e) {
return po(Va, e, Xs(e));
}
function toPlainMonthDay$1(e) {
return yo(_a, e, Xs(e));
}
function toLocaleString$5(e, n, t) {
const [a, o] = Si(n, t, e);
return a.format(o);
}
function toLocaleStringParts$4(e, n, t) {
const [a, o] = Si(n, t, e);
return a.formatToParts(o);
}
function rangeToLocaleString$4(e, n, t, a) {
const [o, r, s] = Si(t, a, e, n);
return o.formatRange(r, s);
}
function rangeToLocaleStringParts$4(e, n, t, a) {
const [o, r, s] = Si(t, a, e, n);
return o.formatRangeToParts(r, s);
}
function withDayOfYear$1(e, n, t) {
return Do(moveToDayOfYear(e, n, t));
}
function withDayOfMonth$1(e, n, t) {
return Do(moveToDayOfMonth(e, n, t));
}
function withDayOfWeek$1(e, n, t) {
return Do(moveToDayOfWeek(e, n, t));
}
function withWeekOfYear$1(e, n, t) {
return Do(slotsWithWeekOfYear(e, n, t));
}
function addYears$1(e, n, t) {
return Do(moveByYears(e, n, t));
}
function addMonths$1(e, n, t) {
return Do(moveByMonths(e, n, t));
}
function addWeeks$1(e, n) {
return Do(moveByIsoWeeks(e, n));
}
function addDays$1(e, n) {
return Do(moveByDaysStrict(e, n));
}
function moveByTimeUnit(e, n, t) {
const a = ma(n), o = so(a, Ge(Ba(t), e));
return Do({
...n,
...So(o, 0)
});
}
function roundToInterval$1(e, n, t, a) {
const [, o] = co(e, a);
return jt(Do(roundDateTimeToInterval(n, t, o)));
}
function aligned$1(e, n = 0) {
return t => {
let a = e(t);
return n && (a = So(ma(a), n)), jt(Do({
...t,
...a
}));
};
}
function fromFields$4(e, n) {
return de(Aa(getCalendarIdFromBag(e)), e, n);
}
function isInstance$4(e) {
return Boolean(e) && e.branding === G;
}
function withFields$4(e, n, t) {
return ee(mo, e, n, t);
}
function withCalendar(e, n) {
return Ot(e, Zt(n));
}
function toZonedDateTime$1(e, n) {
return ae(Me, Io, L, e, "string" == typeof n ? {
timeZone: n
} : n);
}
function toPlainYearMonth(e) {
return le(Va, e, pc(e));
}
function toPlainMonthDay(e) {
return se(_a, e, pc(e));
}
function toLocaleString$4(e, n, t) {
const [a, o] = Nc(n, t, e);
return a.format(o);
}
function toLocaleStringParts$3(e, n, t) {
const [a, o] = Nc(n, t, e);
return a.formatToParts(o);
}
function rangeToLocaleString$3(e, n, t, a) {
const [o, r, s] = Nc(t, a, e, n);
return o.formatRange(r, s);
}
function rangeToLocaleStringParts$3(e, n, t, a) {
const [o, r, s] = Nc(t, a, e, n);
return o.formatRangeToParts(r, s);
}
function withDayOfYear(e, n, t) {
return W(To(moveToDayOfYear(e, n, t)));
}
function withDayOfMonth(e, n, t) {
return W(To(moveToDayOfMonth(e, n, t)));
}
function withDayOfWeek(e, n, t) {
return W(To(moveToDayOfWeek(e, n, t)));
}
function withWeekOfYear(e, n, t) {
return W(To(slotsWithWeekOfYear(e, n, t)));
}
function addYears(e, n, t) {
return To(moveByYears(e, n, t));
}
function addMonths(e, n, t) {
return To(moveByMonths(e, n, t));
}
function addWeeks(e, n) {
return W(To(moveByIsoWeeks(e, n)));
}
function addDays(e, n) {
return W(To(moveByDaysStrict(e, n)));
}
function roundToInterval(e, n, t, a) {
const [, o] = co(e, a), r = roundDateTimeToInterval(n, t, o);
return W(To({
...t,
...r
}));
}
function aligned(e, n = 0) {
return t => {
const a = Ua(e(t), n);
return W(To({
...t,
...a
}));
};
}
function isInstance$3(e) {
return Boolean(e) && e.branding === ft;
}
function withFields$3(e, n, t) {
return rt(sd(e), n, t);
}
function toLocaleString$3(e, n, t) {
const [a, o] = Id(n, t, e);
return a.format(o);
}
function toLocaleStringParts$2(e, n, t) {
const [a, o] = Id(n, t, e);
return a.formatToParts(o);
}
function rangeToLocaleString$2(e, n, t, a) {
const [o, r, s] = Id(t, a, e, n);
return o.formatRange(r, s);
}
function rangeToLocaleStringParts$2(e, n, t, a) {
const [o, r, s] = Id(t, a, e, n);
return o.formatRangeToParts(r, s);
}
function fromFields$2(e, n) {
return Ut(Va(getCalendarIdFromBag(e)), e, n);
}
function isInstance$2(e) {
return Boolean(e) && e.branding === Qt;
}
function withFields$2(e, n, t) {
return Wt(Fo, e, n, t);
}
function toPlainDate$1(e, n) {
return $t(mo, e, Dd(e), n);
}
function toLocaleString$2(e, n, t) {
const [a, o] = Cd(n, t, e);
return a.format(o);
}
function toLocaleStringParts$1(e, n, t) {
const [a, o] = Cd(n, t, e);
return a.formatToParts(o);
}
function rangeToLocaleString$1(e, n, t, a) {
const [o, r, s] = Cd(t, a, e, n);
return o.formatRange(r, s);
}
function rangeToLocaleStringParts$1(e, n, t, a) {
const [o, r, s] = Cd(t, a, e, n);
return o.formatRangeToParts(r, s);
}
function fromFields$1(e, n) {
const t = extractCalendarIdFromBag(e);
return Rt(_a(t || l), !t, e, n);
}
function isInstance$1(e) {
return Boolean(e) && e.branding === qt;
}
function withFields$1(e, n, t) {
return Et(Wo, e, n, t);
}
function toPlainDate(e, n) {
return Vt(mo, e, Nd(e), n);
}
function toLocaleString$1(e, n, t) {
const [a, o] = xd(n, t, e);
return a.format(o);
}
function toLocaleStringParts(e, n, t) {
const [a, o] = xd(n, t, e);
return a.formatToParts(o);
}
function rangeToLocaleString(e, n, t, a) {
const [o, r, s] = xd(t, a, e, n);
return o.formatRange(r, s);
}
function rangeToLocaleStringParts(e, n, t, a) {
const [o, r, s] = xd(t, a, e, n);
return o.formatRangeToParts(r, s);
}
function isInstance(e) {
return Boolean(e) && e.branding === A;
}
function toLocaleString(e, n, t) {
return Intl.DurationFormat ? new Intl.DurationFormat(n, t).format(e) : k(e);
}
function instant() {
return xe(Ue());
}
function zonedDateTime(e, n = Qe()) {
return Xe(Ue(), Me(n), Zt(e));
}
function zonedDateTimeISO(e = Qe()) {
return Xe(Ue(), Me(e), l);
}
function plainDateTime(e, n = Qe()) {
return jt(tn(L(Me(n))), Zt(e));
}
function plainDateTimeISO(e = Qe()) {
return jt(tn(L(Me(e))), l);
}
function plainDate(e, n = Qe()) {
return W(tn(L(Me(n))), Zt(e));
}
function plainDateISO(e = Qe()) {
return W(tn(L(Me(e))), l);
}
function plainTimeISO(e = Qe()) {
return St(tn(L(Me(e))));
}
import { memoize as on, createFormatForPrep as an, constructInstantSlots as qe, epochSecToInstant as ea, epochMilliToInstant as ze, epochMicroToInstant as na, epochNanoToInstant as $e, parseInstant as We, InstantBranding as Re, getEpochSec as ta, getEpochMilli as I, getEpochMicro as aa, getEpochNano as b, bindArgs as gt, moveInstant as Ye, diffInstants as Ee, roundInstant as Le, instantsEqual as Ve, compareInstants as He, requireObjectLike as oa, instantToZonedDateTime as Je, refineCalendarId as Zt, refineTimeZoneId as Me, queryNativeTimeZone as L, formatInstantIso as ke, createFormatPrepper as K, instantConfig as Q, isoCalendarId as l, createNativePartOps as ra, formatMonthCode as sa, createNativeInLeapYearOps as ia, createNativeMonthsInYearOps as ca, createNativeDaysInMonthOps as da, createNativeDaysInYearOps as ua, createNativeDayOfYearOps as la, createNativeWeekOps as $a, extractEpochNano as fa, isoToEpochNano as ma, getCommonTimeZoneId as ga, getCommonCalendarId as ha, createNativeDiffOps as Ia, refineUnitDiffOptions as Ma, compareBigNanos as pa, totalRelativeDuration as ya, roundByInc as Da, prepareZonedEpochDiff as Sa, moveBigNano as Ta, diffBigNanos as va, bigNanoToExactDays as Oa, roundBigNanoByInc as Ya, bigNanoToNumber as La, moveZonedEpochs as Fa, moveDateTime as ka, refineOverflowOptions as dt, createNativeMoveOps as Wa, epochMilliToIso as Pa, nativeYearMonthAdd as wa, toStrictInteger as Ba, pluckProps as nn, isoDateFieldNamesAlpha as Ca, moveByDays as Ua, clampEntity as ba, toInteger as Za, moveToDayOfMonthUnsafe as Na, createNativeDayOps as za, computeIsoDayOfWeek as Ha, unsupportedWeekNumbers as qa, createNativeConvertOps as xa, computeEpochNanoFrac as ja, roundWithMode as Ea, isoTimeFieldDefaults as At, clearIsoFields as Ra, constructZonedDateTimeSlots as ye, refineZonedDateTimeBag as Ae, createNativeDateRefineOps as Aa, parseZonedDateTime as Ne, ZonedDateTimeBranding as _, zonedEpochSlotsToIso as he, formatOffsetNano as Se, isoTimeFieldsToCal as Ga, buildZonedIsoFields as Ja, computeZonedHoursInDay as Te, zonedDateTimeWithFields as De, slotsWithCalendarId as Ot, slotsWithTimeZoneId as ge, zonedDateTimeWithPlainDate as Ka, zonedDateTimeWithPlainTime as Pe, moveZonedDateTime as Oe, diffZonedDateTimes as we, roundZonedDateTime as Ie, computeZonedStartOfDay as be, zonedDateTimesEqual as ve, compareZonedDateTimes as Be, zonedDateTimeToInstant as Ce, zonedDateTimeToPlainDateTime as yt, zonedDateTimeToPlainDate as fe, zonedDateTimeToPlainTime as mt, zonedDateTimeToPlainYearMonth as Qa, createNativeYearMonthRefineOps as Va, zonedDateTimeToPlainMonthDay as Xa, createNativeMonthDayRefineOps as _a, formatZonedDateTimeIso as Fe, nanoInHour as no, nanoInMinute as ao, nanoInSec as oo, nanoInMilli as Ke, nanoInMicro as ro, addBigNanos as so, numberToBigNano as Ge, checkEpochNanoInBounds as io, refineUnitRoundOptions as co, roundZonedEpochToInterval as uo, alignZonedEpoch as lo, getSingleInstantFor as $o, computeIsoDaysInWeek as fo, createNativeDateModOps as mo, zonedConfig as ot, nanoInUtcDay as go, computeDayFloor as ho, constructPlainDateTimeSlots as Mt, refinePlainDateTimeBag as Nt, parsePlainDateTime as Bt, PlainDateTimeBranding as x, identity as Io, plainDateTimeWithFields as Pt, plainDateTimeWithPlainDate as Mo, plainDateTimeWithPlainTime as pt, movePlainDateTime as wt, diffPlainDateTimes as It, roundPlainDateTime as bt, plainDateTimesEqual as vt, compareIsoDateTimeFields as Yt, plainDateTimeToZonedDateTime as Ct, createPlainDateSlots as W, createPlainTimeSlots as St, plainDateTimeToPlainYearMonth as po, plainDateTimeToPlainMonthDay as yo, formatPlainDateTimeIso as Ft, checkIsoDateTimeInBounds as Do, epochNanoToIso as So, createPlainDateTimeSlots as jt, dateTimeConfig as U, constructPlainDateSlots as ue, refinePlainDateBag as de, parsePlainDate as me, PlainDateBranding as G, plainDateWithFields as ee, movePlainDate as ne, diffPlainDates as oe, plainDatesEqual as re, compareIsoDateFields as te, plainDateToZonedDateTime as ae, plainDateToPlainDateTime as ie, plainDateToPlainYearMonth as le, plainDateToPlainMonthDay as se, formatPlainDateIso as ce, checkIsoDateInBounds as To, dateConfig as X, constructPlainTimeSlots as ut, refinePlainTimeBag as Tt, parsePlainTime as ht, PlainTimeBranding as ft, plainTimeWithFields as rt, movePlainTime as at, diffPlainTimes as it, roundPlainTime as lt, plainTimesEqual as st, compareIsoTimeFields as Dt, plainTimeToZonedDateTime as vo, plainTimeToPlainDateTime as Oo, formatPlainTimeIso as ct, timeConfig as tt, constructPlainYearMonthSlots as Kt, refinePlainYearMonthBag as Ut, parsePlainYearMonth as Xt, PlainYearMonthBranding as Qt, plainYearMonthWithFields as Wt, createNativeYearMonthMoveOps as Yo, movePlainYearMonth as Gt, createNativeYearMonthDiffOps as Lo, diffPlainYearMonth as _t, plainYearMonthsEqual as zt, plainYearMonthToPlainDate as $t, formatPlainYearMonthIso as Ht, createNativeYearMonthModOps as Fo, yearMonthConfig as et, constructPlainMonthDaySlots as kt, refLine truncated
const Po = qe, wo = ea, Bo = ze, Co = na, Uo = $e, bo = We, Zo = ta, No = I, zo = aa, Ho = b, qo = /*@__PURE__*/ gt(Ye, 0), xo = /*@__PURE__*/ gt(Ye, 1), jo = /*@__PURE__*/ gt(Ee, 0), Eo = /*@__PURE__*/ gt(Ee, 1), Ro = Le, Ao = Ve, Go = He, Jo = /*@__PURE__*/ K(Q,
/*@__PURE__*/ createFormatCache()), Ko = /*@__PURE__*/ gt(ke, Me, L), Qo = /*@__PURE__*/ gt(diffZonedLargeUnits, 9), Vo = /*@__PURE__*/ gt(diffZonedLargeUnits, 8), Xo = /*@__PURE__*/ gt(diffZonedDayLikeUnits, 7, 7), _o = /*@__PURE__*/ gt(diffZonedDayLikeUnits, 6, 1), er = /*@__PURE__*/ gt(diffTimeUnit, fa), nr = /*@__PURE__*/ gt(diffPlainLargeUnits, 9), tr = /*@__PURE__*/ gt(diffPlainLargeUnits, 8), ar = /*@__PURE__*/ gt(diffPlainDayLikeUnit, ma, 7, 7), or = /*@__PURE__*/ gt(diffPlainDayLikeUnit, ma, 6, 1), rr = /*@__PURE__*/ gt(diffTimeUnit, ma), sr = "dayOfMonth", ir = "day", cr = "dayOfWeek", dr = "weekOfYear", ur = /*@__PURE__*/ gt(Ra, 5), lr = /*@__PURE__*/ gt(Ra, 4), $r = /*@__PURE__*/ gt(Ra, 3), fr = /*@__PURE__*/ gt(Ra, 2), mr = /*@__PURE__*/ gt(Ra, 1), gr = /*@__PURE__*/ gt(ye, Zt, Me), hr = Ne, Ir = /*@__PURE__*/ on((e => {
const n = he(e, L), t = Se(n.offsetNanoseconds);
return {
...computeDateFields(n),
...Ga(n),
offset: t
};
}), WeakMap), Mr = /*@__PURE__*/ gt(Ja, L), pr = getCalendarId, yr = ta, Dr = I, Sr = aa, Tr = b, vr = /*@__PURE__*/ adaptDateFunc(Ha), Or = /*@__PURE__*/ adaptDateFunc(fo), Yr = /*@__PURE__*/ adaptDateFunc(computeWeekOfYear), Lr = /*@__PURE__*/ adaptDateFunc(computeYearOfWeek), Fr = /*@__PURE__*/ adaptDateFunc(computeDayOfYear), kr = /*@__PURE__*/ adaptDateFunc(computeDaysInMonth), Wr = /*@__PURE__*/ adaptDateFunc(computeDaysInYear), Pr = /*@__PURE__*/ adaptDateFunc(computeMonthsInYear), wr = /*@__PURE__*/ adaptDateFunc(computeInLeapYear), Br = /*@__PURE__*/ gt(Te, L), Cr = /*@__PURE__*/ gt(Ka, L), Ur = /*@__PURE__*/ gt(Pe, L), br = /*@__PURE__*/ gt(Oe, Wa, L, 0), Zr = /*@__PURE__*/ gt(Oe, Wa, L, 1), Nr = /*@__PURE__*/ gt(we, Ia, L, 0), zr = /*@__PURE__*/ gt(we, Ia, L, 1), Hr = /*@__PURE__*/ gt(Ie, L), qr = /*@__PURE__*/ gt(be, L), xr = ve, jr = Be, Er = Ce, Rr = /*@__PURE__*/ gt(yt, L), Ar = /*@__PURE__*/ gt(fe, L), Gr = /*@__PURE__*/ gt(mt, L), Jr = /*@__PURE__*/ K(ot,
/*@__PURE__*/ createFormatCache()), Kr = /*@__PURE__*/ gt(Fe, L), Qr = /*@__PURE__*/ zonedTransform(moveToDayOfYear), Vr = /*@__PURE__*/ zonedTransform(moveToDayOfMonth), Xr = /*@__PURE__*/ zonedTransform(moveToDayOfWeek), _r = /*@__PURE__*/ zonedTransform(slotsWithWeekOfYear), es = /*@__PURE__*/ zonedTransform(moveByYears), ns = /*@__PURE__*/ zonedTransform(moveByMonths), ts = /*@__PURE__*/ zonedTransform(moveByIsoWeeks), as = /*@__PURE__*/ zonedTransform(moveByDaysStrict), os = /*@__PURE__*/ gt(moveByTimeUnit$1, no), rs = /*@__PURE__*/ gt(moveByTimeUnit$1, ao), ss = /*@__PURE__*/ gt(moveByTimeUnit$1, oo), is = /*@__PURE__*/ gt(moveByTimeUnit$1, Ke), cs = /*@__PURE__*/ gt(moveByTimeUnit$1, ro), ds = /*@__PURE__*/ gt(moveByTimeUnit$1, 1), us = /*@__PURE__*/ reversedMove(es), ls = /*@__PURE__*/ reversedMove(ns), $s = /*@__PURE__*/ reversedMove(ts), fs = /*@__PURE__*/ reversedMove(as), ms = /*@__PURE__*/ reversedMove(os), gs = /*@__PURE__*/ reversedMove(rs), hs = /*@__PURE__*/ reversedMove(ss), Is = /*@__PURE__*/ reversedMove(is), Ms = /*@__PURE__*/ reversedMove(cs), ps = /*@__PURE__*/ reversedMove(ds), ys = /*@__PURE__*/ gt(rountToInterval, 9, computeYearInterval), Ds = /*@__PURE__*/ gt(rountToInterval, 8, computeMonthInterval), Ss = /*@__PURE__*/ gt(rountToInterval, 7, computeIsoWeekInterval), Ts = /*@__PURE__*/ aligned$2(computeYearFloor), vs = /*@__PURE__*/ aligned$2(computeMonthFloor), Os = /*@__PURE__*/ aligned$2(computeIsoWeekFloor), Ys = /*@__PURE__*/ aligned$2(ur), Ls = /*@__PURE__*/ aligned$2(lr), Fs = /*@__PURE__*/ aligned$2($r), ks = /*@__PURE__*/ aligned$2(fr), Ws = /*@__PURE__*/ aligned$2(mr), Ps = /*@__PURE__*/ aligned$2(computeYearCeil, -1), ws = /*@__PURE__*/ aligned$2(computeMonthCeil, -1), Bs = /*@__PURE__*/ aligned$2(computeIsoWeekCeil, -1), Cs = /*@__PURE__*/ aligned$2(ho, go - 1), Us = /*@__PURE__*/ aligned$2(ur, no - 1), bs = /*@__PURE__*/ aligned$2(lr, ao - 1), Zs = /*@__PURE__*/ aligned$2($r, oo - 1), Ns = /*@__PURE__*/ aligned$2(fr, Ke - 1), zs = /*@__PURE__*/ aligned$2(mr, ro - 1), Hs = Qo, qs = Vo, xs = Xo, js = _o, Es = /*@__PURE__*/ gt(er, 5, no), Rs = /*@__PURE__*/ gt(er, 4, ao), As = /*@__PURE__*/ gt(er, 3, oo), Gs = /*@__PURE__*/ gt(er, 2, Ke), Js = /*@__PURE__*/ gt(er, 1, ro), Ks = /*@__PURE__*/ gt(er, 0, 1), Qs = /*@__PURE__*/ gt(Mt, Zt), Vs = Bt, Xs = /*@__PURE__*/ on((e => ({
...computeDateFields(e),
...Ga(e)
})), WeakMap), _s = Io, ei = getCalendarId, ni = Ha, ti = fo, ai = computeWeekOfYear, oi = computeYearOfWeek, ri = computeDayOfYear, si = computeDaysInMonth, ii = computeDaysInYear, ci = computeMonthsInYear, di = computeInLeapYear, ui = Mo, li = pt, $i = /*@__PURE__*/ gt(wt, Wa, 0), fi = /*@__PURE__*/ gt(wt, Wa, 1), mi = /*@__PURE__*/ gt(It, Ia, 0), gi = /*@__PURE__*/ gt(It, Ia, 1), hi = bt, Ii = vt, Mi = Yt, pi = /*@__PURE__*/ gt(Ct, L), yi = W, Di = St, Si = /*@__PURE__*/ K(U,
/*@__PURE__*/ createFormatCache()), Ti = Ft, vi = /*@__PURE__*/ gt(moveByTimeUnit, no), Oi = /*@__PURE__*/ gt(moveByTimeUnit, ao), Yi = /*@__PURE__*/ gt(moveByTimeUnit, oo), Li = /*@__PURE__*/ gt(moveByTimeUnit, Ke), Fi = /*@__PURE__*/ gt(moveByTimeUnit, ro), ki = /*@__PURE__*/ gt(moveByTimeUnit, 1), Wi = /*@__PURE__*/ reversedMove(addYears$1), Pi = /*@__PURE__*/ reversedMove(addMonths$1), wi = /*@__PURE__*/ reversedMove(addWeeks$1), Bi = /*@__PURE__*/ reversedMove(addDays$1), Ci = /*@__PURE__*/ reversedMove(vi), Ui = /*@__PURE__*/ reversedMove(Oi), bi = /*@__PURE__*/ reversedMove(Yi), Zi = /*@__PURE__*/ reversedMove(Li), Ni = /*@__PURE__*/ reversedMove(Fi), zi = /*@__PURE__*/ reversedMove(ki), Hi = /*@__PURE__*/ gt(roundToInterval$1, 9, computeYearInterval), qi = /*@__PURE__*/ gt(roundToInterval$1, 8, computeMonthInterval), xi = /*@__PURE__*/ gt(roundToInterval$1, 7, computeIsoWeekInterval), ji = /*@__PURE__*/ aligned$1(computeYearFloor), Ei = /*@__PURE__*/ aligned$1(computeMonthFloor), Ri = /*@__PURE__*/ aligned$1(computeIsoWeekFloor), Ai = /*@__PURE__*/ aligned$1(ho), Gi = /*@__PURE__*/ aligned$1(ur), Ji = /*@__PURE__*/ aligned$1(lr), Ki = /*@__PURE__*/ aligned$1($r), Qi = /*@__PURE__*/ aligned$1(fr), Vi = /*@__PURE__*/ aligned$1(mr), Xi = /*@__PURE__*/ aligned$1(computeYearCeil, -1), _i = /*@__PURE__*/ aligned$1(computeMonthCeil, -1), ec = /*@__PURE__*/ aligned$1(computeIsoWeekCeil, -1), nc = /*@__PURE__*/ aligned$1(ho, go - 1), tc = /*@__PURE__*/ aligned$1(ur, no - 1), ac = /*@__PURE__*/ aligned$1(lr, ao - 1), oc = /*@__PURE__*/ aligned$1($r, oo - 1), rc = /*@__PURE__*/ aligned$1(fr, Ke - 1), sc = /*@__PURE__*/ aligned$1(mr, ro - 1), ic = nr, cc = tr, dc = ar, uc = or, lc = /*@__PURE__*/ gt(rr, 5, no), $c = /*@__PURE__*/ gt(rr, 4, ao), fc = /*@__PURE__*/ gt(rr, 3, oo), mc = /*@__PURE__*/ gt(rr, 2, Ke), gc = /*@__PURE__*/ gt(rr, 1, ro), hc = /*@__PURE__*/ gt(rr, 0, 1), Ic = /*@__PURE__*/ gt(ue, Zt), Mc = me, pc = /*@__PURE__*/ on(computeDateFields, WeakMap), yc = Io, Dc = getCalendarId, Sc = Ha, Tc = fo, vc = computeWeekOfYear, Oc = computeYearOfWeek, Yc = computeDayOfYear, Lc = computeDaysInMonth, Fc = computeDaysInYear, kc = computeMonthsInYear, Wc = computeInLeapYear, Pc = /*@__PURE__*/ gt(ne, Wa, 0), wc = /*@__PURE__*/ gt(ne, Wa, 1), Bc = /*@__PURE__*/ gt(oe, Ia, 0), Cc = /*@__PURE__*/ gt(oe, Ia, 1), Uc = re, bc = te, Zc = ie, Nc = /*@__PURE__*/ K(X,
/*@__PURE__*/ createFormatCache()), zc = ce, Hc = /*@__PURE__*/ reversedMove(addYears), qc = /*@__PURE__*/ reversedMove(addMonths), xc = /*@__PURE__*/ reversedMove(addWeeks), jc = /*@__PURE__*/ reversedMove(addDays), Ec = /*@__PURE__*/ gt(roundToInterval, 9, computeYearInterval), Rc = /*@__PURE__*/ gt(roundToInterval, 8, computeMonthInterval), Ac = /*@__PURE__*/ gt(roundToInterval, 7, computeIsoWeekInterval), Gc = /*@__PURE__*/ aligned(computeYearFloor), Jc = /*@__PURE__*/ aligned(computeMonthFloor), Kc = /*@__PURE__*/ aligned(computeIsoWeekFloor), Qc = /*@__PURE__*/ aligned(computeYearCeil, -1), Vc = /*@__PURE__*/ aligned(computeMonthCeil, -1), Xc = /*@__PURE__*/ aligned(computeIsoWeekCeil, -1), _c = nr, ed = tr, nd = ar, td = or, ad = ut, od = Tt, rd = ht, sd = /*@__PURE__*/ on(Ga, WeakMap), id = Io, cd = /*@__PURE__*/ gt(at, 0), dd = /*@__PURE__*/ gt(at, 1), ud = /*@__PURE__*/ gt(it, 0), ld = /*@__PURE__*/ gt(it, 1), $d = lt, fd = st, md = Dt, gd = /*@__PURE__*/ gt(vo, Me, Io, L), hd = Oo, Id = /*@__PURE__*/ K(tt,
/*@__PURE__*/ createFormatCache()), Md = ct, pd = /*@__PURE__*/ gt(Kt, Zt), yd = /*@__PURE__*/ gt(Xt, za), Dd = /*@__PURE__*/ on(computeYearMonthFields, WeakMap), Sd = Io, Td = getCalendarId, vd = computeDaysInMonth, Od = computeDaysInYear, Yd = computeMonthsInYear, Ld = computeInLeapYear, Fd = /*@__PURE__*/ gt(Gt, Yo, 0), kd = /*@__PURE__*/ gt(Gt, Yo, 1), Wd = /*@__PURE__*/ gt(_t, Lo, 0), Pd = /*@__PURE__*/ gt(_t, Lo, 1), wd = zt, Bd = te, Cd = /*@__PURE__*/ K(et,
/*@__PURE__*/ createFormatCache()), Ud = Ht, bd = /*@__PURE__*/ gt(kt, Zt), Zd = /*@__PURE__*/ gt(xt, ko), Nd = /*@__PURE__*/ on(computeMonthDayFields, WeakMap), zd = Io, Hd = getCalendarId, qd = Lt, xd = /*@__PURE__*/ K(nt,
/*@__PURE__*/ createFormatCache()), jd = Jt, Ed = j, Rd = q, Ad = R, Gd = y, Jd = N, Kd = B, Qd = Y, Vd = /*@__PURE__*/ gt(E, Io, Ia, L, 0), Xd = /*@__PURE__*/ gt(E, Io, Ia, L, 1), _d = /*@__PURE__*/ gt(V, Io, Ia, L), eu = /*@__PURE__*/ gt(J, Io, Ia, L), nu = /*@__PURE__*/ gt(H, Io, Ia, L), tu = k, au = Qe;
export { Qd as abs, qo as add, br as add$1, $i as add$2, Pc as add$3, cd as add$4, Fd as add$5, Vd as add$6, as as addDays, addDays$1, addDays as addDays$2, os as addHours, vi as addHours$1, cs as addMicroseconds, Fi as addMicroseconds$1, is as addMilliseconds, Li as addMilliseconds$1, rs as addMinutes, Oi as addMinutes$1, ns as addMonths, addMonths$1, addMonths as addMonths$2, ds as addNanoseconds, ki as addNanoseconds$1, ss as addSeconds, Yi as addSeconds$1, ts as addWeeks, addWeeks$1, addWeeks as addWeeks$2, es as addYears, addYears$1, addYears as addYears$2, Gd as blank, pr as calendarId, ei as calendarId$1, Dc as calendarId$2, Td as calendarId$3, Hd as calendarId$4, Go as compare, jr as compare$1, Mi as compare$2, bc as compare$3, md as compare$4, Bd as compare$5, nu as compare$6, Po as create, gr as create$1, Qs as create$2, Ic as create$3, ad as create$4, pd as create$5, bd as create$6, Ed as create$7, vr as dayOfWeek, ni as dayOfWeek$1, Sc as dayOfWeek$2, Fr as dayOfYear, ri as dayOfYear$1, Yc as dayOfYear$2, kr as daysInMonth, si as daysInMonth$1, Lc as daysInMonth$2, vd as daysInMonth$3, Or as daysInWeek, ti as daysInWeek$1, Tc as daysInWeek$2, Wr as daysInYear, ii as daysInYear$1, Fc as daysInYear$2, Od as daysInYear$3, js as diffDays, uc as diffDays$1, td as diffDays$2, Es as diffHours, lc as diffHours$1, Js as diffMicroseconds, gc as diffMicroseconds$1, Gs as diffMilliseconds, mc as diffMilliseconds$1, Rs as diffMinutes, $c as diffMinutes$1, qs as diffMonths, cc as diffMonths$1, ed as diffMonths$2, Ks as diffNanoseconds, hc as diffNanoseconds$1, As as diffSeconds, fc as diffSeconds$1, xs as diffWeeks, dc as diffWeeks$1, nd as diffWeeks$2, Hs as diffYears, ic as diffYears$1, _c as diffYears$2, Cs as endOfDay, nc as endOfDay$1, Us as endOfHour, tc as endOfHour$1, zs as endOfMicrosecond, sc as endOfMicrosecond$1, Ns as endOfMillisecond, rc as endOfMillisecond$1, bs as endOfMinute, ac as endOfMinute$1, ws as endOfMonth, _i as endOfMonth$1, Vc as endOfMonth$2, Zs as endOfSecond, oc as endOfSecond$1, Bs as endOfWeek, ec as endOfWeek$1, Xc as endOfWeek$2, Ps as endOfYear, Xi as endOfYear$1, Qc as endOfYear$2, zo as epochMicroseconds, Sr as epochMicroseconds$1, No as epochMilliseconds, Dr as epochMilliseconds$1, Ho as epochNanoseconds, Tr as epochNanoseconds$1, Zo as epochSeconds, yr as epochSeconds$1, Ao as equals, xr as equals$1, Ii as equals$2, Uc as equals$3, fd as equals$4, wd as equals$5, qd as equals$6, Co as fromEpochMicroseconds, Bo as fromEpochMilliseconds, Uo as fromEpochNanoseconds, wo as fromEpochSeconds, fromFields$6 as fromFields, fromFields$5 as fromFields$1, fromFields$4 as fromFields$2, od as fromFields$3, fromFields$2 as fromFields$4, fromFields$1 as fromFields$5, Rd as fromFields$6, bo as fromString, hr as fromString$1, Vs as fromString$2, Mc as fromString$3, rd as fromString$4, yd as fromString$5, Zd as fromString$6, Ad as fromString$7, Ir as getFields, Xs as getFields$1, pc as getFields$2, sd as getFields$3, Dd as getFields$4, Nd as getFields$5, Mr as getISOFields, _s as getISOFields$1, yc as getISOFields$2, id as getISOFields$3, Sd as getISOFields$4, zd as getISOFields$5, Br as hoursInDay, wr as inLeapYear, di as inLeapYear$1, Wc as inLeapYear$2, Ld as inLeapYear$3, instant, isInstance$7 as isInstance, isInstance$6 as isInstance$1, isInstance$5 as isInstance$2, isInstance$4 as isInstance$3, isInstance$3 as isInstance$4, isInstance$2 as isInstance$5, isInstance$1 as isInstance$6, isInstance as isInstance$7, Pr as monthsInYear, ci as monthsInYear$1, kc as monthsInYear$2, Yd as monthsInYear$3, Kd as negated, offset, offsetNanoseconds, plainDate, plainDateISO, plainDateTime, plainDateTimeISO, plainTimeISO, rangeToLocaleString$6 as rangeToLocaleString, rangeToLocaleString$5 as rangeToLocaleString$1, rangeToLocaleString$4 as rangeToLocaleString$2, rangeToLocaleString$3, rangeToLocaleString$2 as rangeToLocaleString$4, rangeToLocaleString$1 as rangeToLocaleString$5, rangeToLocaleString as rangeToLocaleString$6, rangeToLocaleStringParts$6 as rangeToLocaleStringParts, rangeToLocaleStringParts$5 as rangeToLocaleStringParts$1, rangeToLocaleStringParts$4 as rangeToLocaleStringParts$2, rangeToLocaleStringParts$3, rangeToLocaleStringParts$2 as rangeToLocaleStringParts$4, rangeToLocaleStringParts$1 as rangeToLocaleStringParts$5, rangeToLocaleStringParts as rangeToLocaleStringParts$6, Ro as round, Hr as round$1, hi as round$2, $d as round$3, _d as round$4, Ds as roundToMonth, qi as roundToMonth$1, Rc as roundToMonth$2, Ss as roundToWeek, xi as roundToWeek$1, Ac as roundToWeek$2, ys as roundToYear, Hi as roundToYear$1, Ec as roundToYear$2, Eo as since, zr as since$1, gi as since$2, Cc as since$3, ld as since$4, Pd as since$5, qr as startOfDay, Ai as startOfDay$1, Ys as startOfHour, Gi as startOfHour$1, Ws as startOfMicrosecond, Vi as startOfMicrosecond$1, ks as startOfMillisecond, Qi as startOfMillisecond$1, Ls as startOfMinute, Ji as startOfMinute$1, vs as startOfMonth, Ei as startOfMonth$1, Jc Line truncated
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,202 @@
import { Temporal } from 'temporal-spec';
type SubsecDigits = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
type NumberSign = -1 | 0 | 1;
type BigNano = [days: number, timeNano: number];
type LocalesArg = string | string[];
interface DurationDateFields {
days: number;
weeks: number;
months: number;
years: number;
}
interface DurationTimeFields {
nanoseconds: number;
microseconds: number;
milliseconds: number;
seconds: number;
minutes: number;
hours: number;
}
type DurationFields = DurationDateFields & DurationTimeFields;
type DurationYearMonthFieldName = 'years' | 'months';
type DurationDateFieldName = DurationYearMonthFieldName | 'weeks' | 'days';
type DurationTimeFieldName = 'hours' | 'minutes' | 'seconds' | 'milliseconds' | 'microseconds' | 'nanoseconds';
type DurationDayTimeFieldName = 'day' | DurationTimeFieldName;
type DurationFieldName = DurationDateFieldName | DurationTimeFieldName;
type StrictYearMonthUnitName = 'year' | 'month';
type StrictDateUnitName = StrictYearMonthUnitName | 'week' | 'day';
type StrictTimeUnitName = 'hour' | 'minute' | 'second' | 'millisecond' | 'microsecond' | 'nanosecond';
type StrictDayTimeUnitName = 'day' | StrictTimeUnitName;
type StrictUnitName = StrictDateUnitName | StrictTimeUnitName;
type YearMonthUnitName = StrictYearMonthUnitName | DurationYearMonthFieldName;
type DateUnitName = StrictDateUnitName | DurationDateFieldName;
type TimeUnitName = StrictTimeUnitName | DurationTimeFieldName;
type DayTimeUnitName = StrictDayTimeUnitName | DurationDayTimeFieldName;
type UnitName = StrictUnitName | DurationFieldName;
type ZonedFieldOptions = OverflowOptions & EpochDisambigOptions & OffsetDisambigOptions;
type RoundingMathOptions = RoundingIncOptions & RoundingModeOptions;
type DiffOptions<UN extends UnitName> = LargestUnitOptions<UN> & SmallestUnitOptions<UN> & RoundingMathOptions;
type RoundingOptions<UN extends DayTimeUnitName> = Required<SmallestUnitOptions<UN>> & RoundingMathOptions;
type DurationRoundingOptions<RA> = Required<SmallestUnitOptions<UnitName>> & LargestUnitOptions<UnitName> & RoundingMathOptions & RelativeToOptions<RA>;
type TimeDisplayOptions = SmallestUnitOptions<TimeUnitName> & RoundingModeOptions & SubsecDigitsOptions;
type ZonedDateTimeDisplayOptions = CalendarDisplayOptions & TimeZoneDisplayOptions & OffsetDisplayOptions & TimeDisplayOptions;
type RelativeToOptions<RA> = {
relativeTo?: RA;
};
type DurationTotalOptions<RA> = TotalUnitOptions & RelativeToOptions<RA>;
type DateTimeDisplayOptions = CalendarDisplayOptions & TimeDisplayOptions;
interface SmallestUnitOptions<UN extends UnitName> {
smallestUnit?: UN;
}
interface LargestUnitOptions<UN extends UnitName> {
largestUnit?: UN;
}
interface TotalUnitOptions {
unit: UnitName;
}
type InstantDisplayOptions = {
timeZone?: string;
} & TimeDisplayOptions;
interface OverflowOptions {
overflow?: Temporal.AssignmentOptions['overflow'];
}
interface EpochDisambigOptions {
disambiguation?: Temporal.ToInstantOptions['disambiguation'];
}
interface OffsetDisambigOptions {
offset?: Temporal.OffsetDisambiguationOptions['offset'];
}
interface CalendarDisplayOptions {
calendarName?: Temporal.ShowCalendarOption['calendarName'];
}
interface TimeZoneDisplayOptions {
timeZoneName?: Temporal.ZonedDateTimeToStringOptions['timeZoneName'];
}
interface OffsetDisplayOptions {
offset?: Temporal.ZonedDateTimeToStringOptions['offset'];
}
type RoundingModeName = Temporal.DifferenceOptions<any>['roundingMode'];
interface RoundingModeOptions {
roundingMode?: RoundingModeName;
}
interface RoundingIncOptions {
roundingIncrement?: Temporal.DifferenceOptions<any>['roundingIncrement'];
}
interface SubsecDigitsOptions {
fractionalSecondDigits?: SubsecDigits;
}
interface IsoDateFields {
isoDay: number;
isoMonth: number;
isoYear: number;
}
interface IsoTimeFields {
isoNanosecond: number;
isoMicrosecond: number;
isoMillisecond: number;
isoSecond: number;
isoMinute: number;
isoHour: number;
}
type IsoDateTimeFields = IsoDateFields & IsoTimeFields;
declare const PlainYearMonthBranding: "PlainYearMonth";
declare const PlainMonthDayBranding: "PlainMonthDay";
declare const PlainDateBranding: "PlainDate";
declare const PlainDateTimeBranding: "PlainDateTime";
declare const PlainTimeBranding: "PlainTime";
declare const ZonedDateTimeBranding: "ZonedDateTime";
declare const InstantBranding: "Instant";
declare const DurationBranding: "Duration";
type EpochSlots = {
epochNanoseconds: BigNano;
};
type EpochAndZoneSlots = EpochSlots & {
timeZone: string;
};
type ZonedEpochSlots = EpochAndZoneSlots & {
calendar: string;
};
type DateSlots = IsoDateFields & {
calendar: string;
};
type ZonedDateTimeSlots = ZonedEpochSlots & {
branding: typeof ZonedDateTimeBranding;
};
interface EraYearFields {
era: string;
eraYear: number;
}
type YearFields = Partial<EraYearFields> & {
year: number;
};
interface MonthFields {
monthCode: string;
month: number;
}
interface DayFields {
day: number;
}
type YearMonthFields = YearFields & MonthFields;
type DateFields = YearMonthFields & DayFields;
type MonthDayFields = MonthFields & DayFields;
interface TimeFields {
hour: number;
microsecond: number;
millisecond: number;
minute: number;
nanosecond: number;
second: number;
}
type DateTimeFields = DateFields & TimeFields;
type YearMonthBag = Partial<YearMonthFields>;
type DateBag = Partial<DateFields>;
type MonthDayBag = Partial<MonthDayFields>;
type DurationBag = Partial<DurationFields>;
type TimeBag = Partial<TimeFields>;
type DateTimeBag = DateBag & TimeBag;
type EraYearOrYear = EraYearFields | {
year: number;
};
type ZonedIsoFields = IsoDateTimeFields & {
calendar: string;
timeZone: string;
offset: string;
};
type ZonedDateTimeFields = DateTimeFields & {
offset: string;
};
type Marker = IsoDateFields | IsoDateTimeFields | ZonedEpochSlots;
type PlainDateBag = DateBag & {
calendar?: string;
};
type PlainDateTimeBag = DateBag & TimeBag & {
calendar?: string;
};
type ZonedDateTimeBag = PlainDateTimeBag & {
timeZone: string;
offset?: string;
};
type PlainTimeBag = TimeBag;
type PlainYearMonthBag = YearMonthBag & {
calendar?: string;
};
type PlainMonthDayBag = MonthDayBag & {
calendar?: string;
};
declare function getCurrentTimeZoneId(): string;
export { type BigNano, type CalendarDisplayOptions, type DateBag, type DateFields, type DateSlots, type DateTimeBag, type DateTimeDisplayOptions, type DateTimeFields, type DateUnitName, type DayTimeUnitName, type DiffOptions, type DurationBag, DurationBranding, type DurationFields, type DurationRoundingOptions, type DurationTotalOptions, type EpochDisambigOptions, type EraYearOrYear, InstantBranding, type InstantDisplayOptions, type IsoDateFields, type IsoDateTimeFields, type IsoTimeFields, type LocalesArg, type Marker, type MonthDayBag, type MonthDayFields, type NumberSign, type OverflowOptions, type PlainDateBag, PlainDateBranding, type PlainDateTimeBag, PlainDateTimeBranding, type PlainMonthDayBag, PlainMonthDayBranding, type PlainTimeBag, PlainTimeBranding, type PlainYearMonthBag, PlainYearMonthBranding, type RelativeToOptions, type RoundingMathOptions, type RoundingModeName, type RoundingOptions, type TimeBag, type TimeDisplayOptions, type TimeFields, type TimeUnitName, type UnitName, type YearMonthBag, type YearMonthFields, type YearMonthUnitName, type ZonedDateTimeBag, ZonedDateTimeBranding, type ZonedDateTimeDisplayOptions, type ZonedDateTimeFields, type ZonedDateTimeSlots, type ZonedFieldOptions, type ZonedIsoFields, getCurrentTimeZoneId };
@@ -0,0 +1,202 @@
import { Temporal } from 'temporal-spec';
type SubsecDigits = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
type NumberSign = -1 | 0 | 1;
type BigNano = [days: number, timeNano: number];
type LocalesArg = string | string[];
interface DurationDateFields {
days: number;
weeks: number;
months: number;
years: number;
}
interface DurationTimeFields {
nanoseconds: number;
microseconds: number;
milliseconds: number;
seconds: number;
minutes: number;
hours: number;
}
type DurationFields = DurationDateFields & DurationTimeFields;
type DurationYearMonthFieldName = 'years' | 'months';
type DurationDateFieldName = DurationYearMonthFieldName | 'weeks' | 'days';
type DurationTimeFieldName = 'hours' | 'minutes' | 'seconds' | 'milliseconds' | 'microseconds' | 'nanoseconds';
type DurationDayTimeFieldName = 'day' | DurationTimeFieldName;
type DurationFieldName = DurationDateFieldName | DurationTimeFieldName;
type StrictYearMonthUnitName = 'year' | 'month';
type StrictDateUnitName = StrictYearMonthUnitName | 'week' | 'day';
type StrictTimeUnitName = 'hour' | 'minute' | 'second' | 'millisecond' | 'microsecond' | 'nanosecond';
type StrictDayTimeUnitName = 'day' | StrictTimeUnitName;
type StrictUnitName = StrictDateUnitName | StrictTimeUnitName;
type YearMonthUnitName = StrictYearMonthUnitName | DurationYearMonthFieldName;
type DateUnitName = StrictDateUnitName | DurationDateFieldName;
type TimeUnitName = StrictTimeUnitName | DurationTimeFieldName;
type DayTimeUnitName = StrictDayTimeUnitName | DurationDayTimeFieldName;
type UnitName = StrictUnitName | DurationFieldName;
type ZonedFieldOptions = OverflowOptions & EpochDisambigOptions & OffsetDisambigOptions;
type RoundingMathOptions = RoundingIncOptions & RoundingModeOptions;
type DiffOptions<UN extends UnitName> = LargestUnitOptions<UN> & SmallestUnitOptions<UN> & RoundingMathOptions;
type RoundingOptions<UN extends DayTimeUnitName> = Required<SmallestUnitOptions<UN>> & RoundingMathOptions;
type DurationRoundingOptions<RA> = Required<SmallestUnitOptions<UnitName>> & LargestUnitOptions<UnitName> & RoundingMathOptions & RelativeToOptions<RA>;
type TimeDisplayOptions = SmallestUnitOptions<TimeUnitName> & RoundingModeOptions & SubsecDigitsOptions;
type ZonedDateTimeDisplayOptions = CalendarDisplayOptions & TimeZoneDisplayOptions & OffsetDisplayOptions & TimeDisplayOptions;
type RelativeToOptions<RA> = {
relativeTo?: RA;
};
type DurationTotalOptions<RA> = TotalUnitOptions & RelativeToOptions<RA>;
type DateTimeDisplayOptions = CalendarDisplayOptions & TimeDisplayOptions;
interface SmallestUnitOptions<UN extends UnitName> {
smallestUnit?: UN;
}
interface LargestUnitOptions<UN extends UnitName> {
largestUnit?: UN;
}
interface TotalUnitOptions {
unit: UnitName;
}
type InstantDisplayOptions = {
timeZone?: string;
} & TimeDisplayOptions;
interface OverflowOptions {
overflow?: Temporal.AssignmentOptions['overflow'];
}
interface EpochDisambigOptions {
disambiguation?: Temporal.ToInstantOptions['disambiguation'];
}
interface OffsetDisambigOptions {
offset?: Temporal.OffsetDisambiguationOptions['offset'];
}
interface CalendarDisplayOptions {
calendarName?: Temporal.ShowCalendarOption['calendarName'];
}
interface TimeZoneDisplayOptions {
timeZoneName?: Temporal.ZonedDateTimeToStringOptions['timeZoneName'];
}
interface OffsetDisplayOptions {
offset?: Temporal.ZonedDateTimeToStringOptions['offset'];
}
type RoundingModeName = Temporal.DifferenceOptions<any>['roundingMode'];
interface RoundingModeOptions {
roundingMode?: RoundingModeName;
}
interface RoundingIncOptions {
roundingIncrement?: Temporal.DifferenceOptions<any>['roundingIncrement'];
}
interface SubsecDigitsOptions {
fractionalSecondDigits?: SubsecDigits;
}
interface IsoDateFields {
isoDay: number;
isoMonth: number;
isoYear: number;
}
interface IsoTimeFields {
isoNanosecond: number;
isoMicrosecond: number;
isoMillisecond: number;
isoSecond: number;
isoMinute: number;
isoHour: number;
}
type IsoDateTimeFields = IsoDateFields & IsoTimeFields;
declare const PlainYearMonthBranding: "PlainYearMonth";
declare const PlainMonthDayBranding: "PlainMonthDay";
declare const PlainDateBranding: "PlainDate";
declare const PlainDateTimeBranding: "PlainDateTime";
declare const PlainTimeBranding: "PlainTime";
declare const ZonedDateTimeBranding: "ZonedDateTime";
declare const InstantBranding: "Instant";
declare const DurationBranding: "Duration";
type EpochSlots = {
epochNanoseconds: BigNano;
};
type EpochAndZoneSlots = EpochSlots & {
timeZone: string;
};
type ZonedEpochSlots = EpochAndZoneSlots & {
calendar: string;
};
type DateSlots = IsoDateFields & {
calendar: string;
};
type ZonedDateTimeSlots = ZonedEpochSlots & {
branding: typeof ZonedDateTimeBranding;
};
interface EraYearFields {
era: string;
eraYear: number;
}
type YearFields = Partial<EraYearFields> & {
year: number;
};
interface MonthFields {
monthCode: string;
month: number;
}
interface DayFields {
day: number;
}
type YearMonthFields = YearFields & MonthFields;
type DateFields = YearMonthFields & DayFields;
type MonthDayFields = MonthFields & DayFields;
interface TimeFields {
hour: number;
microsecond: number;
millisecond: number;
minute: number;
nanosecond: number;
second: number;
}
type DateTimeFields = DateFields & TimeFields;
type YearMonthBag = Partial<YearMonthFields>;
type DateBag = Partial<DateFields>;
type MonthDayBag = Partial<MonthDayFields>;
type DurationBag = Partial<DurationFields>;
type TimeBag = Partial<TimeFields>;
type DateTimeBag = DateBag & TimeBag;
type EraYearOrYear = EraYearFields | {
year: number;
};
type ZonedIsoFields = IsoDateTimeFields & {
calendar: string;
timeZone: string;
offset: string;
};
type ZonedDateTimeFields = DateTimeFields & {
offset: string;
};
type Marker = IsoDateFields | IsoDateTimeFields | ZonedEpochSlots;
type PlainDateBag = DateBag & {
calendar?: string;
};
type PlainDateTimeBag = DateBag & TimeBag & {
calendar?: string;
};
type ZonedDateTimeBag = PlainDateTimeBag & {
timeZone: string;
offset?: string;
};
type PlainTimeBag = TimeBag;
type PlainYearMonthBag = YearMonthBag & {
calendar?: string;
};
type PlainMonthDayBag = MonthDayBag & {
calendar?: string;
};
declare function getCurrentTimeZoneId(): string;
export { type BigNano, type CalendarDisplayOptions, type DateBag, type DateFields, type DateSlots, type DateTimeBag, type DateTimeDisplayOptions, type DateTimeFields, type DateUnitName, type DayTimeUnitName, type DiffOptions, type DurationBag, DurationBranding, type DurationFields, type DurationRoundingOptions, type DurationTotalOptions, type EpochDisambigOptions, type EraYearOrYear, InstantBranding, type InstantDisplayOptions, type IsoDateFields, type IsoDateTimeFields, type IsoTimeFields, type LocalesArg, type Marker, type MonthDayBag, type MonthDayFields, type NumberSign, type OverflowOptions, type PlainDateBag, PlainDateBranding, type PlainDateTimeBag, PlainDateTimeBranding, type PlainMonthDayBag, PlainMonthDayBranding, type PlainTimeBag, PlainTimeBranding, type PlainYearMonthBag, PlainYearMonthBranding, type RelativeToOptions, type RoundingMathOptions, type RoundingModeName, type RoundingOptions, type TimeBag, type TimeDisplayOptions, type TimeFields, type TimeUnitName, type UnitName, type YearMonthBag, type YearMonthFields, type YearMonthUnitName, type ZonedDateTimeBag, ZonedDateTimeBranding, type ZonedDateTimeDisplayOptions, type ZonedDateTimeFields, type ZonedDateTimeSlots, type ZonedFieldOptions, type ZonedIsoFields, getCurrentTimeZoneId };
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,12 @@
"use strict";
require("../chunks/internal.cjs");
var funcApi = require("../chunks/funcApi.cjs");
exports.abs = funcApi.abs, exports.add = funcApi.add$6, exports.blank = funcApi.blank,
exports.compare = funcApi.compare$6, exports.create = funcApi.create$7, exports.fromFields = funcApi.fromFields$6,
exports.fromString = funcApi.fromString$7, exports.isInstance = funcApi.isInstance$7,
exports.negated = funcApi.negated, exports.round = funcApi.round$4, exports.subtract = funcApi.subtract$6,
exports.toLocaleString = funcApi.toLocaleString$7, exports.toString = funcApi.toString$7,
exports.total = funcApi.total, exports.withFields = funcApi.withFields$6;
@@ -0,0 +1,43 @@
import { DurationFields, DurationBranding, NumberSign, DurationBag, RelativeToOptions, DurationRoundingOptions, DurationTotalOptions, TimeDisplayOptions, UnitName, LocalesArg } from '../chunks/internal.js';
import { Record as Record$3 } from './plaindate.js';
import { Record as Record$2 } from './plaindatetime.js';
import { Record as Record$1 } from './zoneddatetime.js';
type Record = Readonly<DurationFields> & {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof DurationBranding;
readonly sign: NumberSign;
};
type FromFields = DurationBag;
type WithFields = DurationBag;
type RelativeToRecord = Record$1 | Record$2 | Record$3;
type ArithmeticOptions = RelativeToOptions<RelativeToRecord>;
type RoundOptions = DurationRoundingOptions<RelativeToRecord>;
type TotalOptions = DurationTotalOptions<RelativeToRecord>;
type CompareOptions = RelativeToOptions<RelativeToRecord>;
type ToStringOptions = TimeDisplayOptions;
declare const create: (years?: number, months?: number, weeks?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, microseconds?: number, nanoseconds?: number) => Record;
declare const fromFields: (fields: FromFields) => Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const blank: (record: Record) => boolean;
declare const withFields: (record: Record, fields: WithFields) => Record;
declare const negated: (record: Record) => Record;
declare const abs: (record: Record) => Record;
declare const add: (record0: Record, record1: Record, options?: ArithmeticOptions) => Record;
declare const subtract: (record0: Record, record1: Record, options?: ArithmeticOptions) => Record;
declare const round: (record: Record, options?: RoundOptions) => Record;
declare const total: (record: Record, options?: UnitName | TotalOptions) => number;
declare const compare: (record0: Record, record1: Record, options?: CompareOptions) => NumberSign;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare const toString: (record: Record, options?: ToStringOptions) => string;
export { type ArithmeticOptions, type CompareOptions, type FromFields, type Record, type RelativeToRecord, type RoundOptions, type ToStringOptions, type TotalOptions, type WithFields, abs, add, blank, compare, create, fromFields, fromString, isInstance, negated, round, subtract, toLocaleString, toString, total, withFields };
@@ -0,0 +1,43 @@
import { DurationFields, DurationBranding, NumberSign, DurationBag, RelativeToOptions, DurationRoundingOptions, DurationTotalOptions, TimeDisplayOptions, UnitName, LocalesArg } from '../chunks/internal.js';
import { Record as Record$3 } from './plaindate.js';
import { Record as Record$2 } from './plaindatetime.js';
import { Record as Record$1 } from './zoneddatetime.js';
type Record = Readonly<DurationFields> & {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof DurationBranding;
readonly sign: NumberSign;
};
type FromFields = DurationBag;
type WithFields = DurationBag;
type RelativeToRecord = Record$1 | Record$2 | Record$3;
type ArithmeticOptions = RelativeToOptions<RelativeToRecord>;
type RoundOptions = DurationRoundingOptions<RelativeToRecord>;
type TotalOptions = DurationTotalOptions<RelativeToRecord>;
type CompareOptions = RelativeToOptions<RelativeToRecord>;
type ToStringOptions = TimeDisplayOptions;
declare const create: (years?: number, months?: number, weeks?: number, days?: number, hours?: number, minutes?: number, seconds?: number, milliseconds?: number, microseconds?: number, nanoseconds?: number) => Record;
declare const fromFields: (fields: FromFields) => Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const blank: (record: Record) => boolean;
declare const withFields: (record: Record, fields: WithFields) => Record;
declare const negated: (record: Record) => Record;
declare const abs: (record: Record) => Record;
declare const add: (record0: Record, record1: Record, options?: ArithmeticOptions) => Record;
declare const subtract: (record0: Record, record1: Record, options?: ArithmeticOptions) => Record;
declare const round: (record: Record, options?: RoundOptions) => Record;
declare const total: (record: Record, options?: UnitName | TotalOptions) => number;
declare const compare: (record0: Record, record1: Record, options?: CompareOptions) => NumberSign;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare const toString: (record: Record, options?: ToStringOptions) => string;
export { type ArithmeticOptions, type CompareOptions, type FromFields, type Record, type RelativeToRecord, type RoundOptions, type ToStringOptions, type TotalOptions, type WithFields, abs, add, blank, compare, create, fromFields, fromString, isInstance, negated, round, subtract, toLocaleString, toString, total, withFields };
@@ -0,0 +1,3 @@
import "../chunks/internal.js";
export { abs, add$6 as add, blank, compare$6 as compare, create$7 as create, fromFields$6 as fromFields, fromString$7 as fromString, isInstance$7 as isInstance, negated, round$4 as round, subtract$6 as subtract, toLocaleString$7 as toLocaleString, toString$7 as toString, total, withFields$6 as withFields } from "../chunks/funcApi.js";
@@ -0,0 +1,18 @@
"use strict";
require("../chunks/internal.cjs");
var funcApi = require("../chunks/funcApi.cjs");
exports.add = funcApi.add, exports.compare = funcApi.compare, exports.create = funcApi.create,
exports.epochMicroseconds = funcApi.epochMicroseconds, exports.epochMilliseconds = funcApi.epochMilliseconds,
exports.epochNanoseconds = funcApi.epochNanoseconds, exports.epochSeconds = funcApi.epochSeconds,
exports.equals = funcApi.equals, exports.fromEpochMicroseconds = funcApi.fromEpochMicroseconds,
exports.fromEpochMilliseconds = funcApi.fromEpochMilliseconds, exports.fromEpochNanoseconds = funcApi.fromEpochNanoseconds,
exports.fromEpochSeconds = funcApi.fromEpochSeconds, exports.fromString = funcApi.fromString,
exports.isInstance = funcApi.isInstance, exports.rangeToLocaleString = funcApi.rangeToLocaleString,
exports.rangeToLocaleStringParts = funcApi.rangeToLocaleStringParts, exports.round = funcApi.round,
exports.since = funcApi.since, exports.subtract = funcApi.subtract, exports.toLocaleString = funcApi.toLocaleString,
exports.toLocaleStringParts = funcApi.toLocaleStringParts, exports.toString = funcApi.toString,
exports.toZonedDateTime = funcApi.toZonedDateTime, exports.toZonedDateTimeISO = funcApi.toZonedDateTimeISO,
exports.until = funcApi.until;
@@ -0,0 +1,55 @@
import { InstantBranding, BigNano, DiffOptions, TimeUnitName, RoundingOptions, InstantDisplayOptions, UnitName, NumberSign, LocalesArg } from '../chunks/internal.js';
import { Record as Record$1 } from './duration.js';
import { Record as Record$2 } from './zoneddatetime.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof InstantBranding;
/**
* @deprecated Use the epochNanoseconds() function instead.
*/
readonly epochNanoseconds: BigNano;
};
type DifferenceOptions = DiffOptions<TimeUnitName>;
type RoundOptions = RoundingOptions<TimeUnitName>;
type ToStringOptions = InstantDisplayOptions;
type ToZonedDateTimeOptions = {
timeZone: string;
calendar: string;
};
declare const create: (epochNanoseconds: bigint) => Record;
declare const fromEpochSeconds: (epochSeconds: number) => Record;
declare const fromEpochMilliseconds: (epochMilliseconds: number) => Record;
declare const fromEpochMicroseconds: (epochMicroseconds: bigint) => Record;
declare const fromEpochNanoseconds: (epochNanoseconds: bigint) => Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const epochSeconds: (record: Record) => number;
declare const epochMilliseconds: (record: Record) => number;
declare const epochMicroseconds: (record: Record) => bigint;
declare const epochNanoseconds: (record: Record) => bigint;
declare const add: (instantRecord: Record, durationRecord: Record$1) => Record;
declare const subtract: (instantRecord: Record, durationRecord: Record$1) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$1;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$1;
declare const round: (record: Record, options?: UnitName | RoundOptions) => Record;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare function toZonedDateTime(record: Record, options: ToZonedDateTimeOptions): Record$2;
declare function toZonedDateTimeISO(record: Record, timeZone: string): Record$2;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
export { type DifferenceOptions, type Record, type RoundOptions, type ToStringOptions, type ToZonedDateTimeOptions, add, compare, create, epochMicroseconds, epochMilliseconds, epochNanoseconds, epochSeconds, equals, fromEpochMicroseconds, fromEpochMilliseconds, fromEpochNanoseconds, fromEpochSeconds, fromString, isInstance, rangeToLocaleString, rangeToLocaleStringParts, round, since, subtract, toLocaleString, toLocaleStringParts, toString, toZonedDateTime, toZonedDateTimeISO, until };
@@ -0,0 +1,55 @@
import { InstantBranding, BigNano, DiffOptions, TimeUnitName, RoundingOptions, InstantDisplayOptions, UnitName, NumberSign, LocalesArg } from '../chunks/internal.js';
import { Record as Record$1 } from './duration.js';
import { Record as Record$2 } from './zoneddatetime.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof InstantBranding;
/**
* @deprecated Use the epochNanoseconds() function instead.
*/
readonly epochNanoseconds: BigNano;
};
type DifferenceOptions = DiffOptions<TimeUnitName>;
type RoundOptions = RoundingOptions<TimeUnitName>;
type ToStringOptions = InstantDisplayOptions;
type ToZonedDateTimeOptions = {
timeZone: string;
calendar: string;
};
declare const create: (epochNanoseconds: bigint) => Record;
declare const fromEpochSeconds: (epochSeconds: number) => Record;
declare const fromEpochMilliseconds: (epochMilliseconds: number) => Record;
declare const fromEpochMicroseconds: (epochMicroseconds: bigint) => Record;
declare const fromEpochNanoseconds: (epochNanoseconds: bigint) => Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const epochSeconds: (record: Record) => number;
declare const epochMilliseconds: (record: Record) => number;
declare const epochMicroseconds: (record: Record) => bigint;
declare const epochNanoseconds: (record: Record) => bigint;
declare const add: (instantRecord: Record, durationRecord: Record$1) => Record;
declare const subtract: (instantRecord: Record, durationRecord: Record$1) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$1;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$1;
declare const round: (record: Record, options?: UnitName | RoundOptions) => Record;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare function toZonedDateTime(record: Record, options: ToZonedDateTimeOptions): Record$2;
declare function toZonedDateTimeISO(record: Record, timeZone: string): Record$2;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
export { type DifferenceOptions, type Record, type RoundOptions, type ToStringOptions, type ToZonedDateTimeOptions, add, compare, create, epochMicroseconds, epochMilliseconds, epochNanoseconds, epochSeconds, equals, fromEpochMicroseconds, fromEpochMilliseconds, fromEpochNanoseconds, fromEpochSeconds, fromString, isInstance, rangeToLocaleString, rangeToLocaleStringParts, round, since, subtract, toLocaleString, toLocaleStringParts, toString, toZonedDateTime, toZonedDateTimeISO, until };
@@ -0,0 +1,3 @@
import "../chunks/internal.js";
export { add, compare, create, epochMicroseconds, epochMilliseconds, epochNanoseconds, epochSeconds, equals, fromEpochMicroseconds, fromEpochMilliseconds, fromEpochNanoseconds, fromEpochSeconds, fromString, isInstance, rangeToLocaleString, rangeToLocaleStringParts, round, since, subtract, toLocaleString, toLocaleStringParts, toString, toZonedDateTime, toZonedDateTimeISO, until } from "../chunks/funcApi.js";
@@ -0,0 +1,10 @@
"use strict";
require("../chunks/internal.cjs");
var funcApi = require("../chunks/funcApi.cjs");
exports.instant = funcApi.instant, exports.plainDate = funcApi.plainDate, exports.plainDateISO = funcApi.plainDateISO,
exports.plainDateTime = funcApi.plainDateTime, exports.plainDateTimeISO = funcApi.plainDateTimeISO,
exports.plainTimeISO = funcApi.plainTimeISO, exports.timeZoneId = funcApi.timeZoneId$1,
exports.zonedDateTime = funcApi.zonedDateTime, exports.zonedDateTimeISO = funcApi.zonedDateTimeISO;
@@ -0,0 +1,22 @@
import { getCurrentTimeZoneId } from '../chunks/internal.js';
import { Record } from './instant.js';
import { Record as Record$3 } from './plaindate.js';
import { Record as Record$2 } from './plaindatetime.js';
import { Record as Record$4 } from './plaintime.js';
import { Record as Record$1 } from './zoneddatetime.js';
declare const timeZoneId: typeof getCurrentTimeZoneId;
declare function instant(): Record;
declare function zonedDateTime(calendar: string, timeZone?: string): Record$1;
declare function zonedDateTimeISO(timeZone?: string): Record$1;
declare function plainDateTime(calendar: string, timeZone?: string): Record$2;
declare function plainDateTimeISO(timeZone?: string): Record$2;
declare function plainDate(calendar: string, timeZone?: string): Record$3;
declare function plainDateISO(timeZone?: string): Record$3;
declare function plainTimeISO(timeZone?: string): Record$4;
export { instant, plainDate, plainDateISO, plainDateTime, plainDateTimeISO, plainTimeISO, timeZoneId, zonedDateTime, zonedDateTimeISO };
@@ -0,0 +1,22 @@
import { getCurrentTimeZoneId } from '../chunks/internal.js';
import { Record } from './instant.js';
import { Record as Record$3 } from './plaindate.js';
import { Record as Record$2 } from './plaindatetime.js';
import { Record as Record$4 } from './plaintime.js';
import { Record as Record$1 } from './zoneddatetime.js';
declare const timeZoneId: typeof getCurrentTimeZoneId;
declare function instant(): Record;
declare function zonedDateTime(calendar: string, timeZone?: string): Record$1;
declare function zonedDateTimeISO(timeZone?: string): Record$1;
declare function plainDateTime(calendar: string, timeZone?: string): Record$2;
declare function plainDateTimeISO(timeZone?: string): Record$2;
declare function plainDate(calendar: string, timeZone?: string): Record$3;
declare function plainDateISO(timeZone?: string): Record$3;
declare function plainTimeISO(timeZone?: string): Record$4;
export { instant, plainDate, plainDateISO, plainDateTime, plainDateTimeISO, plainTimeISO, timeZoneId, zonedDateTime, zonedDateTimeISO };
@@ -0,0 +1,3 @@
import "../chunks/internal.js";
export { instant, plainDate, plainDateISO, plainDateTime, plainDateTimeISO, plainTimeISO, timeZoneId$1 as timeZoneId, zonedDateTime, zonedDateTimeISO } from "../chunks/funcApi.js";
@@ -0,0 +1,32 @@
"use strict";
require("../chunks/internal.cjs");
var funcApi = require("../chunks/funcApi.cjs");
exports.add = funcApi.add$3, exports.addDays = funcApi.addDays$2, exports.addMonths = funcApi.addMonths$2,
exports.addWeeks = funcApi.addWeeks$2, exports.addYears = funcApi.addYears$2, exports.calendarId = funcApi.calendarId$2,
exports.compare = funcApi.compare$3, exports.create = funcApi.create$3, exports.dayOfWeek = funcApi.dayOfWeek$2,
exports.dayOfYear = funcApi.dayOfYear$2, exports.daysInMonth = funcApi.daysInMonth$2,
exports.daysInWeek = funcApi.daysInWeek$2, exports.daysInYear = funcApi.daysInYear$2,
exports.diffDays = funcApi.diffDays$2, exports.diffMonths = funcApi.diffMonths$2,
exports.diffWeeks = funcApi.diffWeeks$2, exports.diffYears = funcApi.diffYears$2,
exports.endOfMonth = funcApi.endOfMonth$2, exports.endOfWeek = funcApi.endOfWeek$2,
exports.endOfYear = funcApi.endOfYear$2, exports.equals = funcApi.equals$3, exports.fromFields = funcApi.fromFields$2,
exports.fromString = funcApi.fromString$3, exports.getFields = funcApi.getFields$2,
exports.getISOFields = funcApi.getISOFields$2, exports.inLeapYear = funcApi.inLeapYear$2,
exports.isInstance = funcApi.isInstance$3, exports.monthsInYear = funcApi.monthsInYear$2,
exports.rangeToLocaleString = funcApi.rangeToLocaleString$3, exports.rangeToLocaleStringParts = funcApi.rangeToLocaleStringParts$3,
exports.roundToMonth = funcApi.roundToMonth$2, exports.roundToWeek = funcApi.roundToWeek$2,
exports.roundToYear = funcApi.roundToYear$2, exports.since = funcApi.since$3, exports.startOfMonth = funcApi.startOfMonth$2,
exports.startOfWeek = funcApi.startOfWeek$2, exports.startOfYear = funcApi.startOfYear$2,
exports.subtract = funcApi.subtract$3, exports.subtractDays = funcApi.subtractDays$2,
exports.subtractMonths = funcApi.subtractMonths$2, exports.subtractWeeks = funcApi.subtractWeeks$2,
exports.subtractYears = funcApi.subtractYears$2, exports.toLocaleString = funcApi.toLocaleString$3,
exports.toLocaleStringParts = funcApi.toLocaleStringParts$3, exports.toPlainDateTime = funcApi.toPlainDateTime$1,
exports.toPlainMonthDay = funcApi.toPlainMonthDay$2, exports.toPlainYearMonth = funcApi.toPlainYearMonth$2,
exports.toString = funcApi.toString$3, exports.toZonedDateTime = funcApi.toZonedDateTime$2,
exports.until = funcApi.until$3, exports.weekOfYear = funcApi.weekOfYear$2, exports.withCalendar = funcApi.withCalendar$2,
exports.withDayOfMonth = funcApi.withDayOfMonth$2, exports.withDayOfWeek = funcApi.withDayOfWeek$2,
exports.withDayOfYear = funcApi.withDayOfYear$2, exports.withFields = funcApi.withFields$2,
exports.withWeekOfYear = funcApi.withWeekOfYear$2, exports.yearOfWeek = funcApi.yearOfWeek$2;
@@ -0,0 +1,105 @@
import * as temporal_spec from 'temporal-spec';
import { PlainDateBranding, DateFields, PlainDateBag, DateBag, IsoDateFields, OverflowOptions, DiffOptions, DateUnitName, CalendarDisplayOptions, NumberSign, LocalesArg, RoundingMathOptions, RoundingModeName } from '../chunks/internal.js';
import { Record as Record$2 } from './duration.js';
import { Record as Record$4 } from './plaindatetime.js';
import { Record as Record$6 } from './plainmonthday.js';
import { Record as Record$1 } from './plaintime.js';
import { Record as Record$5 } from './plainyearmonth.js';
import { Record as Record$3 } from './zoneddatetime.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof PlainDateBranding;
/**
* @deprecated Use the calendarId() function instead.
*/
readonly calendar: string;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoYear: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMonth: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoDay: number;
};
type Fields = DateFields;
type FromFields = PlainDateBag;
type WithFields = DateBag;
type ISOFields = IsoDateFields;
type AssignmentOptions = OverflowOptions;
type ArithmeticOptions = OverflowOptions;
type DifferenceOptions = DiffOptions<DateUnitName>;
type ToStringOptions = CalendarDisplayOptions;
type ToZonedDateTimeOptions = {
timeZone: string;
plainTime?: Record$1;
};
declare const create: (isoYear: number, isoMonth: number, isoDay: number, calendar?: string) => Record;
declare function fromFields(fields: FromFields, options?: AssignmentOptions): Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (record: Record) => Fields;
declare const getISOFields: (record: Record) => ISOFields;
declare const calendarId: (record: Record) => string;
declare const dayOfWeek: (record: Record) => number;
declare const daysInWeek: (record: Record) => number;
declare const weekOfYear: (record: Record) => number | undefined;
declare const yearOfWeek: (record: Record) => number | undefined;
declare const dayOfYear: (record: Record) => number;
declare const daysInMonth: (record: Record) => number;
declare const daysInYear: (record: Record) => number;
declare const monthsInYear: (record: Record) => number;
declare const inLeapYear: (record: Record) => boolean;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare function withCalendar(record: Record, calendar: string): Record;
declare const add: (plainDateRecord: Record, durationRecord: Record$2, options?: ArithmeticOptions) => Record;
declare const subtract: (plainDateRecord: Record, durationRecord: Record$2, options?: ArithmeticOptions) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$2;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$2;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare function toZonedDateTime(record: Record, options: string | ToZonedDateTimeOptions): Record$3;
declare const toPlainDateTime: (plainDateRecord: Record, plainTimeRecord?: Record$1) => Record$4;
declare function toPlainYearMonth(record: Record): Record$5;
declare function toPlainMonthDay(record: Record): Record$6;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
declare function withDayOfYear(record: Record, dayOfYear: number, options?: OverflowOptions): Record;
declare function withDayOfMonth(record: Record, dayOfMonth: number, options?: OverflowOptions): Record;
declare function withDayOfWeek(record: Record, dayOfWeek: number, options?: OverflowOptions): Record;
declare function withWeekOfYear(record: Record, weekOfYear: number, options?: OverflowOptions): Record;
declare function addYears(record: Record, years: number, options?: OverflowOptions): Record;
declare function addMonths(record: Record, months: number, options?: OverflowOptions): Record;
declare function addWeeks(record: Record, weeks: number): Record;
declare function addDays(record: Record, days: number): Record;
declare const subtractYears: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMonths: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractWeeks: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractDays: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const roundToYear: (record0: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToMonth: (record0: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToWeek: (record0: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const startOfYear: (record: Record) => Record;
declare const startOfMonth: (record: Record) => Record;
declare const startOfWeek: (record: Record) => Record;
declare const endOfYear: (record: Record) => Record;
declare const endOfMonth: (record: Record) => Record;
declare const endOfWeek: (record: Record) => Record;
declare const diffYears: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffMonths: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffWeeks: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffDays: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
export { type ArithmeticOptions, type AssignmentOptions, type DifferenceOptions, type Fields, type FromFields, type ISOFields, type Record, type ToStringOptions, type ToZonedDateTimeOptions, type WithFields, add, addDays, addMonths, addWeeks, addYears, calendarId, compare, create, dayOfWeek, dayOfYear, daysInMonth, daysInWeek, daysInYear, diffDays, diffMonths, diffWeeks, diffYears, endOfMonth, endOfWeek, endOfYear, equals, fromFields, fromString, getFields, getISOFields, inLeapYear, isInstance, monthsInYear, rangeToLocaleString, rangeToLocaleStringParts, roundToMonth, roundToWeek, roundToYear, since, startOfMonth, startOfWeek, startOfYear, subtract, subtractDays, subtractMonths, subtractWeeks, subtractYears, toLocaleString, toLocaleStringParts, toPlainDateTime, toPlainMonthDay, toPlainYearMonth, toString, toZonedDateTime, until, weekOfYear, withCalendar, withDayOfMonth, withDayOfWeek, withDayOfYear, withFields, withWeekOfYear, yearOfWeek };
@@ -0,0 +1,105 @@
import * as temporal_spec from 'temporal-spec';
import { PlainDateBranding, DateFields, PlainDateBag, DateBag, IsoDateFields, OverflowOptions, DiffOptions, DateUnitName, CalendarDisplayOptions, NumberSign, LocalesArg, RoundingMathOptions, RoundingModeName } from '../chunks/internal.js';
import { Record as Record$2 } from './duration.js';
import { Record as Record$4 } from './plaindatetime.js';
import { Record as Record$6 } from './plainmonthday.js';
import { Record as Record$1 } from './plaintime.js';
import { Record as Record$5 } from './plainyearmonth.js';
import { Record as Record$3 } from './zoneddatetime.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof PlainDateBranding;
/**
* @deprecated Use the calendarId() function instead.
*/
readonly calendar: string;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoYear: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMonth: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoDay: number;
};
type Fields = DateFields;
type FromFields = PlainDateBag;
type WithFields = DateBag;
type ISOFields = IsoDateFields;
type AssignmentOptions = OverflowOptions;
type ArithmeticOptions = OverflowOptions;
type DifferenceOptions = DiffOptions<DateUnitName>;
type ToStringOptions = CalendarDisplayOptions;
type ToZonedDateTimeOptions = {
timeZone: string;
plainTime?: Record$1;
};
declare const create: (isoYear: number, isoMonth: number, isoDay: number, calendar?: string) => Record;
declare function fromFields(fields: FromFields, options?: AssignmentOptions): Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (record: Record) => Fields;
declare const getISOFields: (record: Record) => ISOFields;
declare const calendarId: (record: Record) => string;
declare const dayOfWeek: (record: Record) => number;
declare const daysInWeek: (record: Record) => number;
declare const weekOfYear: (record: Record) => number | undefined;
declare const yearOfWeek: (record: Record) => number | undefined;
declare const dayOfYear: (record: Record) => number;
declare const daysInMonth: (record: Record) => number;
declare const daysInYear: (record: Record) => number;
declare const monthsInYear: (record: Record) => number;
declare const inLeapYear: (record: Record) => boolean;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare function withCalendar(record: Record, calendar: string): Record;
declare const add: (plainDateRecord: Record, durationRecord: Record$2, options?: ArithmeticOptions) => Record;
declare const subtract: (plainDateRecord: Record, durationRecord: Record$2, options?: ArithmeticOptions) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$2;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$2;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare function toZonedDateTime(record: Record, options: string | ToZonedDateTimeOptions): Record$3;
declare const toPlainDateTime: (plainDateRecord: Record, plainTimeRecord?: Record$1) => Record$4;
declare function toPlainYearMonth(record: Record): Record$5;
declare function toPlainMonthDay(record: Record): Record$6;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
declare function withDayOfYear(record: Record, dayOfYear: number, options?: OverflowOptions): Record;
declare function withDayOfMonth(record: Record, dayOfMonth: number, options?: OverflowOptions): Record;
declare function withDayOfWeek(record: Record, dayOfWeek: number, options?: OverflowOptions): Record;
declare function withWeekOfYear(record: Record, weekOfYear: number, options?: OverflowOptions): Record;
declare function addYears(record: Record, years: number, options?: OverflowOptions): Record;
declare function addMonths(record: Record, months: number, options?: OverflowOptions): Record;
declare function addWeeks(record: Record, weeks: number): Record;
declare function addDays(record: Record, days: number): Record;
declare const subtractYears: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMonths: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractWeeks: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractDays: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const roundToYear: (record0: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToMonth: (record0: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToWeek: (record0: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const startOfYear: (record: Record) => Record;
declare const startOfMonth: (record: Record) => Record;
declare const startOfWeek: (record: Record) => Record;
declare const endOfYear: (record: Record) => Record;
declare const endOfMonth: (record: Record) => Record;
declare const endOfWeek: (record: Record) => Record;
declare const diffYears: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffMonths: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffWeeks: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffDays: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
export { type ArithmeticOptions, type AssignmentOptions, type DifferenceOptions, type Fields, type FromFields, type ISOFields, type Record, type ToStringOptions, type ToZonedDateTimeOptions, type WithFields, add, addDays, addMonths, addWeeks, addYears, calendarId, compare, create, dayOfWeek, dayOfYear, daysInMonth, daysInWeek, daysInYear, diffDays, diffMonths, diffWeeks, diffYears, endOfMonth, endOfWeek, endOfYear, equals, fromFields, fromString, getFields, getISOFields, inLeapYear, isInstance, monthsInYear, rangeToLocaleString, rangeToLocaleStringParts, roundToMonth, roundToWeek, roundToYear, since, startOfMonth, startOfWeek, startOfYear, subtract, subtractDays, subtractMonths, subtractWeeks, subtractYears, toLocaleString, toLocaleStringParts, toPlainDateTime, toPlainMonthDay, toPlainYearMonth, toString, toZonedDateTime, until, weekOfYear, withCalendar, withDayOfMonth, withDayOfWeek, withDayOfYear, withFields, withWeekOfYear, yearOfWeek };
@@ -0,0 +1,3 @@
import "../chunks/internal.js";
export { add$3 as add, addDays$2 as addDays, addMonths$2 as addMonths, addWeeks$2 as addWeeks, addYears$2 as addYears, calendarId$2 as calendarId, compare$3 as compare, create$3 as create, dayOfWeek$2 as dayOfWeek, dayOfYear$2 as dayOfYear, daysInMonth$2 as daysInMonth, daysInWeek$2 as daysInWeek, daysInYear$2 as daysInYear, diffDays$2 as diffDays, diffMonths$2 as diffMonths, diffWeeks$2 as diffWeeks, diffYears$2 as diffYears, endOfMonth$2 as endOfMonth, endOfWeek$2 as endOfWeek, endOfYear$2 as endOfYear, equals$3 as equals, fromFields$2 as fromFields, fromString$3 as fromString, getFields$2 as getFields, getISOFields$2 as getISOFields, inLeapYear$2 as inLeapYear, isInstance$3 as isInstance, monthsInYear$2 as monthsInYear, rangeToLocaleString$3 as rangeToLocaleString, rangeToLocaleStringParts$3 as rangeToLocaleStringParts, roundToMonth$2 as roundToMonth, roundToWeek$2 as roundToWeek, roundToYear$2 as roundToYear, since$3 as since, startOfMonth$2 as startOfMonth, startOfWeek$2 as startOfWeek, startOfYear$2 as startOfYear, subtract$3 as subtract, subtractDays$2 as subtractDays, subtractMonths$2 as subtractMonths, subtractWeeks$2 as subtractWeeks, subtractYears$2 as subtractYears, toLocaleString$3 as toLocaleString, toLocaleStringParts$3 as toLocaleStringParts, toPlainDateTime$1 as toPlainDateTime, toPlainMonthDay$2 as toPlainMonthDay, toPlainYearMonth$2 as toPlainYearMonth, toString$3 as toString, toZonedDateTime$2 as toZonedDateTime, until$3 as until, weekOfYear$2 as weekOfYear, withCalendar$2 as withCalendar, withDayOfMonth$2 as withDayOfMonth, withDayOfWeek$2 as withDayOfWeek, withDayOfYear$2 as withDayOfYear, withFields$2 as withFields, withWeekOfYear$2 as withWeekOfYear, yearOfWeek$2 as yearOfWeek } from "../chunks/funcApi.js";
@@ -0,0 +1,49 @@
"use strict";
require("../chunks/internal.cjs");
var funcApi = require("../chunks/funcApi.cjs");
exports.add = funcApi.add$2, exports.addDays = funcApi.addDays$1, exports.addHours = funcApi.addHours$1,
exports.addMicroseconds = funcApi.addMicroseconds$1, exports.addMilliseconds = funcApi.addMilliseconds$1,
exports.addMinutes = funcApi.addMinutes$1, exports.addMonths = funcApi.addMonths$1,
exports.addNanoseconds = funcApi.addNanoseconds$1, exports.addSeconds = funcApi.addSeconds$1,
exports.addWeeks = funcApi.addWeeks$1, exports.addYears = funcApi.addYears$1, exports.calendarId = funcApi.calendarId$1,
exports.compare = funcApi.compare$2, exports.create = funcApi.create$2, exports.dayOfWeek = funcApi.dayOfWeek$1,
exports.dayOfYear = funcApi.dayOfYear$1, exports.daysInMonth = funcApi.daysInMonth$1,
exports.daysInWeek = funcApi.daysInWeek$1, exports.daysInYear = funcApi.daysInYear$1,
exports.diffDays = funcApi.diffDays$1, exports.diffHours = funcApi.diffHours$1,
exports.diffMicroseconds = funcApi.diffMicroseconds$1, exports.diffMilliseconds = funcApi.diffMilliseconds$1,
exports.diffMinutes = funcApi.diffMinutes$1, exports.diffMonths = funcApi.diffMonths$1,
exports.diffNanoseconds = funcApi.diffNanoseconds$1, exports.diffSeconds = funcApi.diffSeconds$1,
exports.diffWeeks = funcApi.diffWeeks$1, exports.diffYears = funcApi.diffYears$1,
exports.endOfDay = funcApi.endOfDay$1, exports.endOfHour = funcApi.endOfHour$1,
exports.endOfMicrosecond = funcApi.endOfMicrosecond$1, exports.endOfMillisecond = funcApi.endOfMillisecond$1,
exports.endOfMinute = funcApi.endOfMinute$1, exports.endOfMonth = funcApi.endOfMonth$1,
exports.endOfSecond = funcApi.endOfSecond$1, exports.endOfWeek = funcApi.endOfWeek$1,
exports.endOfYear = funcApi.endOfYear$1, exports.equals = funcApi.equals$2, exports.fromFields = funcApi.fromFields$1,
exports.fromString = funcApi.fromString$2, exports.getFields = funcApi.getFields$1,
exports.getISOFields = funcApi.getISOFields$1, exports.inLeapYear = funcApi.inLeapYear$1,
exports.isInstance = funcApi.isInstance$2, exports.monthsInYear = funcApi.monthsInYear$1,
exports.rangeToLocaleString = funcApi.rangeToLocaleString$2, exports.rangeToLocaleStringParts = funcApi.rangeToLocaleStringParts$2,
exports.round = funcApi.round$2, exports.roundToMonth = funcApi.roundToMonth$1,
exports.roundToWeek = funcApi.roundToWeek$1, exports.roundToYear = funcApi.roundToYear$1,
exports.since = funcApi.since$2, exports.startOfDay = funcApi.startOfDay$1, exports.startOfHour = funcApi.startOfHour$1,
exports.startOfMicrosecond = funcApi.startOfMicrosecond$1, exports.startOfMillisecond = funcApi.startOfMillisecond$1,
exports.startOfMinute = funcApi.startOfMinute$1, exports.startOfMonth = funcApi.startOfMonth$1,
exports.startOfSecond = funcApi.startOfSecond$1, exports.startOfWeek = funcApi.startOfWeek$1,
exports.startOfYear = funcApi.startOfYear$1, exports.subtract = funcApi.subtract$2,
exports.subtractDays = funcApi.subtractDays$1, exports.subtractHours = funcApi.subtractHours$1,
exports.subtractMicroseconds = funcApi.subtractMicroseconds$1, exports.subtractMilliseconds = funcApi.subtractMilliseconds$1,
exports.subtractMinutes = funcApi.subtractMinutes$1, exports.subtractMonths = funcApi.subtractMonths$1,
exports.subtractNanoseconds = funcApi.subtractNanoseconds$1, exports.subtractSeconds = funcApi.subtractSeconds$1,
exports.subtractWeeks = funcApi.subtractWeeks$1, exports.subtractYears = funcApi.subtractYears$1,
exports.toLocaleString = funcApi.toLocaleString$2, exports.toLocaleStringParts = funcApi.toLocaleStringParts$2,
exports.toPlainDate = funcApi.toPlainDate$1, exports.toPlainMonthDay = funcApi.toPlainMonthDay$1,
exports.toPlainTime = funcApi.toPlainTime$1, exports.toPlainYearMonth = funcApi.toPlainYearMonth$1,
exports.toString = funcApi.toString$2, exports.toZonedDateTime = funcApi.toZonedDateTime$1,
exports.until = funcApi.until$2, exports.weekOfYear = funcApi.weekOfYear$1, exports.withCalendar = funcApi.withCalendar$1,
exports.withDayOfMonth = funcApi.withDayOfMonth$1, exports.withDayOfWeek = funcApi.withDayOfWeek$1,
exports.withDayOfYear = funcApi.withDayOfYear$1, exports.withFields = funcApi.withFields$1,
exports.withPlainDate = funcApi.withPlainDate$1, exports.withPlainTime = funcApi.withPlainTime$1,
exports.withWeekOfYear = funcApi.withWeekOfYear$1, exports.yearOfWeek = funcApi.yearOfWeek$1;
@@ -0,0 +1,161 @@
import { PlainDateTimeBranding, DateTimeFields, PlainDateTimeBag, DateTimeBag, IsoDateTimeFields, OverflowOptions, DiffOptions, UnitName, RoundingOptions, DayTimeUnitName, EpochDisambigOptions, DateTimeDisplayOptions, NumberSign, LocalesArg, RoundingMathOptions, RoundingModeName, Marker } from '../chunks/internal.js';
import * as temporal_spec from 'temporal-spec';
import { Record as Record$3 } from './duration.js';
import { Record as Record$1 } from './plaindate.js';
import { Record as Record$6 } from './plainmonthday.js';
import { Record as Record$2 } from './plaintime.js';
import { Record as Record$5 } from './plainyearmonth.js';
import { Record as Record$4 } from './zoneddatetime.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
branding: typeof PlainDateTimeBranding;
/**
* @deprecated Use the calendarId() function instead.
*/
readonly calendar: string;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoYear: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMonth: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoDay: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoHour: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMinute: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoSecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMillisecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMicrosecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoNanosecond: number;
};
type Fields = DateTimeFields;
type FromFields = PlainDateTimeBag;
type WithFields = DateTimeBag;
type ISOFields = IsoDateTimeFields;
type AssignmentOptions = OverflowOptions;
type ArithmeticOptions = OverflowOptions;
type DifferenceOptions = DiffOptions<UnitName>;
type RoundOptions = RoundingOptions<DayTimeUnitName>;
type ToZonedDateTimeOptions = EpochDisambigOptions;
type ToStringOptions = DateTimeDisplayOptions;
declare const create: (isoYear: number, isoMonth: number, isoDay: number, isoHour?: number, isoMinute?: number, isoSecond?: number, isoMillisecond?: number, isoMicrosecond?: number, isoNanosecond?: number, calendar?: string) => Record;
declare function fromFields(fields: FromFields, options?: AssignmentOptions): Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (key: Record) => DateTimeFields;
declare const getISOFields: (record: Record) => ISOFields;
declare const calendarId: (record: Record) => string;
declare const dayOfWeek: (record: Record) => number;
declare const daysInWeek: (record: Record) => number;
declare const weekOfYear: (record: Record) => number | undefined;
declare const yearOfWeek: (record: Record) => number | undefined;
declare const dayOfYear: (record: Record) => number;
declare const daysInMonth: (record: Record) => number;
declare const daysInYear: (record: Record) => number;
declare const monthsInYear: (record: Record) => number;
declare const inLeapYear: (record: Record) => boolean;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare function withCalendar(record: Record, calendar: string): Record;
declare const withPlainDate: (plainDateTimeRecord: Record, plainDateRecord: Record$1) => Record;
declare const withPlainTime: (plainDateTimeRecord: Record, plainTimeRecord?: Record$2) => Record;
declare const add: (plainDateTimeRecord: Record, durationRecord: Record$3, options?: ArithmeticOptions) => Record;
declare const subtract: (plainDateTimeRecord: Record, durationRecord: Record$3, options?: ArithmeticOptions) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$3;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$3;
declare const round: (record: Record, options: DayTimeUnitName | RoundOptions) => Record;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare const toZonedDateTime: (record: Record, timeZone: string, options?: ToZonedDateTimeOptions) => Record$4;
declare const toPlainDate: (record: Record) => Record$1;
declare const toPlainTime: (record: Record) => Record$2;
declare function toPlainYearMonth(record: Record): Record$5;
declare function toPlainMonthDay(record: Record): Record$6;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
declare function withDayOfYear(record: Record, dayOfYear: number, options?: OverflowOptions): Record;
declare function withDayOfMonth(record: Record, dayOfMonth: number, options?: OverflowOptions): Record;
declare function withDayOfWeek(record: Record, dayOfWeek: number, options?: OverflowOptions): Record;
declare function withWeekOfYear(record: Record, weekOfYear: number, options?: OverflowOptions): Record;
declare function addYears(record: Record, years: number, options?: OverflowOptions): Record;
declare function addMonths(record: Record, months: number, options?: OverflowOptions): Record;
declare function addWeeks(record: Record, weeks: number): Record;
declare function addDays(record: Record, days: number): Record;
declare const addHours: (record: Record, units: number) => Record;
declare const addMinutes: (record: Record, units: number) => Record;
declare const addSeconds: (record: Record, units: number) => Record;
declare const addMilliseconds: (record: Record, units: number) => Record;
declare const addMicroseconds: (record: Record, units: number) => Record;
declare const addNanoseconds: (record: Record, units: number) => Record;
declare const subtractYears: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMonths: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractWeeks: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractDays: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractHours: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMinutes: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractSeconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMilliseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMicroseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractNanoseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const roundToYear: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToMonth: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToWeek: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const startOfYear: (record: Record) => Record;
declare const startOfMonth: (record: Record) => Record;
declare const startOfWeek: (record: Record) => Record;
declare const startOfDay: (record: Record) => Record;
declare const startOfHour: (record: Record) => Record;
declare const startOfMinute: (record: Record) => Record;
declare const startOfSecond: (record: Record) => Record;
declare const startOfMillisecond: (record: Record) => Record;
declare const startOfMicrosecond: (record: Record) => Record;
declare const endOfYear: (record: Record) => Record;
declare const endOfMonth: (record: Record) => Record;
declare const endOfWeek: (record: Record) => Record;
declare const endOfDay: (record: Record) => Record;
declare const endOfHour: (record: Record) => Record;
declare const endOfMinute: (record: Record) => Record;
declare const endOfSecond: (record: Record) => Record;
declare const endOfMillisecond: (record: Record) => Record;
declare const endOfMicrosecond: (record: Record) => Record;
declare const diffYears: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffMonths: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffWeeks: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffDays: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffHours: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMinutes: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffSeconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMilliseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMicroseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffNanoseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
export { type ArithmeticOptions, type AssignmentOptions, type DifferenceOptions, type Fields, type FromFields, type ISOFields, type Record, type RoundOptions, type ToStringOptions, type ToZonedDateTimeOptions, type WithFields, add, addDays, addHours, addMicroseconds, addMilliseconds, addMinutes, addMonths, addNanoseconds, addSeconds, addWeeks, addYears, calendarId, compare, create, dayOfWeek, dayOfYear, daysInMonth, daysInWeek, daysInYear, diffDays, diffHours, diffMicroseconds, diffMilliseconds, diffMinutes, diffMonths, diffNanoseconds, diffSeconds, diffWeeks, diffYears, endOfDay, endOfHour, endOfMicrosecond, endOfMillisecond, endOfMinute, endOfMonth, endOfSecond, endOfWeek, endOfYear, equals, fromFields, fromString, getFields, getISOFields, inLeapYear, isInstance, monthsInYear, rangeToLocaleString, rangeToLocaleStringParts, round, roundToMonth, roundToWeek, roundToYear, since, startOfDay, startOfHour, startOfMicrosecond, startOfMillisecond, startOfMinute, startOfMonth, startOfSecond, startOfWeek, startOfYear, subtract, subtractDays, subtractHours, subtractMicroseconds, subtractMilliseconds, subtractMinutes, subtractMonths, subtractNanoseconds, subtractSeconds, subtractWeeks, subtractYears, toLocaleString, toLocaleStringParts, toPlainDate, toPlainMonthDay, toPlainTime, toPlainYearMonth, toString, toZonedDateTime, until, weekOfYear, withCalendar, withDayOfMonth, withDayOfWeek, withDayOfYear, withFields, withPlainDate, withPlainTime, withWeekOfYear, yearOfWeek };
@@ -0,0 +1,161 @@
import { PlainDateTimeBranding, DateTimeFields, PlainDateTimeBag, DateTimeBag, IsoDateTimeFields, OverflowOptions, DiffOptions, UnitName, RoundingOptions, DayTimeUnitName, EpochDisambigOptions, DateTimeDisplayOptions, NumberSign, LocalesArg, RoundingMathOptions, RoundingModeName, Marker } from '../chunks/internal.js';
import * as temporal_spec from 'temporal-spec';
import { Record as Record$3 } from './duration.js';
import { Record as Record$1 } from './plaindate.js';
import { Record as Record$6 } from './plainmonthday.js';
import { Record as Record$2 } from './plaintime.js';
import { Record as Record$5 } from './plainyearmonth.js';
import { Record as Record$4 } from './zoneddatetime.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
branding: typeof PlainDateTimeBranding;
/**
* @deprecated Use the calendarId() function instead.
*/
readonly calendar: string;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoYear: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMonth: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoDay: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoHour: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMinute: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoSecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMillisecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMicrosecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoNanosecond: number;
};
type Fields = DateTimeFields;
type FromFields = PlainDateTimeBag;
type WithFields = DateTimeBag;
type ISOFields = IsoDateTimeFields;
type AssignmentOptions = OverflowOptions;
type ArithmeticOptions = OverflowOptions;
type DifferenceOptions = DiffOptions<UnitName>;
type RoundOptions = RoundingOptions<DayTimeUnitName>;
type ToZonedDateTimeOptions = EpochDisambigOptions;
type ToStringOptions = DateTimeDisplayOptions;
declare const create: (isoYear: number, isoMonth: number, isoDay: number, isoHour?: number, isoMinute?: number, isoSecond?: number, isoMillisecond?: number, isoMicrosecond?: number, isoNanosecond?: number, calendar?: string) => Record;
declare function fromFields(fields: FromFields, options?: AssignmentOptions): Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (key: Record) => DateTimeFields;
declare const getISOFields: (record: Record) => ISOFields;
declare const calendarId: (record: Record) => string;
declare const dayOfWeek: (record: Record) => number;
declare const daysInWeek: (record: Record) => number;
declare const weekOfYear: (record: Record) => number | undefined;
declare const yearOfWeek: (record: Record) => number | undefined;
declare const dayOfYear: (record: Record) => number;
declare const daysInMonth: (record: Record) => number;
declare const daysInYear: (record: Record) => number;
declare const monthsInYear: (record: Record) => number;
declare const inLeapYear: (record: Record) => boolean;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare function withCalendar(record: Record, calendar: string): Record;
declare const withPlainDate: (plainDateTimeRecord: Record, plainDateRecord: Record$1) => Record;
declare const withPlainTime: (plainDateTimeRecord: Record, plainTimeRecord?: Record$2) => Record;
declare const add: (plainDateTimeRecord: Record, durationRecord: Record$3, options?: ArithmeticOptions) => Record;
declare const subtract: (plainDateTimeRecord: Record, durationRecord: Record$3, options?: ArithmeticOptions) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$3;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$3;
declare const round: (record: Record, options: DayTimeUnitName | RoundOptions) => Record;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare const toZonedDateTime: (record: Record, timeZone: string, options?: ToZonedDateTimeOptions) => Record$4;
declare const toPlainDate: (record: Record) => Record$1;
declare const toPlainTime: (record: Record) => Record$2;
declare function toPlainYearMonth(record: Record): Record$5;
declare function toPlainMonthDay(record: Record): Record$6;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
declare function withDayOfYear(record: Record, dayOfYear: number, options?: OverflowOptions): Record;
declare function withDayOfMonth(record: Record, dayOfMonth: number, options?: OverflowOptions): Record;
declare function withDayOfWeek(record: Record, dayOfWeek: number, options?: OverflowOptions): Record;
declare function withWeekOfYear(record: Record, weekOfYear: number, options?: OverflowOptions): Record;
declare function addYears(record: Record, years: number, options?: OverflowOptions): Record;
declare function addMonths(record: Record, months: number, options?: OverflowOptions): Record;
declare function addWeeks(record: Record, weeks: number): Record;
declare function addDays(record: Record, days: number): Record;
declare const addHours: (record: Record, units: number) => Record;
declare const addMinutes: (record: Record, units: number) => Record;
declare const addSeconds: (record: Record, units: number) => Record;
declare const addMilliseconds: (record: Record, units: number) => Record;
declare const addMicroseconds: (record: Record, units: number) => Record;
declare const addNanoseconds: (record: Record, units: number) => Record;
declare const subtractYears: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMonths: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractWeeks: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractDays: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractHours: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMinutes: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractSeconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMilliseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMicroseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractNanoseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const roundToYear: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToMonth: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToWeek: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const startOfYear: (record: Record) => Record;
declare const startOfMonth: (record: Record) => Record;
declare const startOfWeek: (record: Record) => Record;
declare const startOfDay: (record: Record) => Record;
declare const startOfHour: (record: Record) => Record;
declare const startOfMinute: (record: Record) => Record;
declare const startOfSecond: (record: Record) => Record;
declare const startOfMillisecond: (record: Record) => Record;
declare const startOfMicrosecond: (record: Record) => Record;
declare const endOfYear: (record: Record) => Record;
declare const endOfMonth: (record: Record) => Record;
declare const endOfWeek: (record: Record) => Record;
declare const endOfDay: (record: Record) => Record;
declare const endOfHour: (record: Record) => Record;
declare const endOfMinute: (record: Record) => Record;
declare const endOfSecond: (record: Record) => Record;
declare const endOfMillisecond: (record: Record) => Record;
declare const endOfMicrosecond: (record: Record) => Record;
declare const diffYears: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffMonths: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffWeeks: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffDays: (record0: Record, record1: Record, options?: RoundingModeName | RoundingMathOptions) => number;
declare const diffHours: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMinutes: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffSeconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMilliseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMicroseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffNanoseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
export { type ArithmeticOptions, type AssignmentOptions, type DifferenceOptions, type Fields, type FromFields, type ISOFields, type Record, type RoundOptions, type ToStringOptions, type ToZonedDateTimeOptions, type WithFields, add, addDays, addHours, addMicroseconds, addMilliseconds, addMinutes, addMonths, addNanoseconds, addSeconds, addWeeks, addYears, calendarId, compare, create, dayOfWeek, dayOfYear, daysInMonth, daysInWeek, daysInYear, diffDays, diffHours, diffMicroseconds, diffMilliseconds, diffMinutes, diffMonths, diffNanoseconds, diffSeconds, diffWeeks, diffYears, endOfDay, endOfHour, endOfMicrosecond, endOfMillisecond, endOfMinute, endOfMonth, endOfSecond, endOfWeek, endOfYear, equals, fromFields, fromString, getFields, getISOFields, inLeapYear, isInstance, monthsInYear, rangeToLocaleString, rangeToLocaleStringParts, round, roundToMonth, roundToWeek, roundToYear, since, startOfDay, startOfHour, startOfMicrosecond, startOfMillisecond, startOfMinute, startOfMonth, startOfSecond, startOfWeek, startOfYear, subtract, subtractDays, subtractHours, subtractMicroseconds, subtractMilliseconds, subtractMinutes, subtractMonths, subtractNanoseconds, subtractSeconds, subtractWeeks, subtractYears, toLocaleString, toLocaleStringParts, toPlainDate, toPlainMonthDay, toPlainTime, toPlainYearMonth, toString, toZonedDateTime, until, weekOfYear, withCalendar, withDayOfMonth, withDayOfWeek, withDayOfYear, withFields, withPlainDate, withPlainTime, withWeekOfYear, yearOfWeek };
@@ -0,0 +1,3 @@
import "../chunks/internal.js";
export { add$2 as add, addDays$1 as addDays, addHours$1 as addHours, addMicroseconds$1 as addMicroseconds, addMilliseconds$1 as addMilliseconds, addMinutes$1 as addMinutes, addMonths$1 as addMonths, addNanoseconds$1 as addNanoseconds, addSeconds$1 as addSeconds, addWeeks$1 as addWeeks, addYears$1 as addYears, calendarId$1 as calendarId, compare$2 as compare, create$2 as create, dayOfWeek$1 as dayOfWeek, dayOfYear$1 as dayOfYear, daysInMonth$1 as daysInMonth, daysInWeek$1 as daysInWeek, daysInYear$1 as daysInYear, diffDays$1 as diffDays, diffHours$1 as diffHours, diffMicroseconds$1 as diffMicroseconds, diffMilliseconds$1 as diffMilliseconds, diffMinutes$1 as diffMinutes, diffMonths$1 as diffMonths, diffNanoseconds$1 as diffNanoseconds, diffSeconds$1 as diffSeconds, diffWeeks$1 as diffWeeks, diffYears$1 as diffYears, endOfDay$1 as endOfDay, endOfHour$1 as endOfHour, endOfMicrosecond$1 as endOfMicrosecond, endOfMillisecond$1 as endOfMillisecond, endOfMinute$1 as endOfMinute, endOfMonth$1 as endOfMonth, endOfSecond$1 as endOfSecond, endOfWeek$1 as endOfWeek, endOfYear$1 as endOfYear, equals$2 as equals, fromFields$1 as fromFields, fromString$2 as fromString, getFields$1 as getFields, getISOFields$1 as getISOFields, inLeapYear$1 as inLeapYear, isInstance$2 as isInstance, monthsInYear$1 as monthsInYear, rangeToLocaleString$2 as rangeToLocaleString, rangeToLocaleStringParts$2 as rangeToLocaleStringParts, round$2 as round, roundToMonth$1 as roundToMonth, roundToWeek$1 as roundToWeek, roundToYear$1 as roundToYear, since$2 as since, startOfDay$1 as startOfDay, startOfHour$1 as startOfHour, startOfMicrosecond$1 as startOfMicrosecond, startOfMillisecond$1 as startOfMillisecond, startOfMinute$1 as startOfMinute, startOfMonth$1 as startOfMonth, startOfSecond$1 as startOfSecond, startOfWeek$1 as startOfWeek, startOfYear$1 as startOfYear, subtract$2 as subtract, subtractDays$1 as subtractDays, subtractHours$1 as subtractHours, subtractMicroseconds$1 as subtractMicroseconds, subtractMilliseconds$1 as subtractMilliseconds, subtractMinutes$1 as subtractMinutes, subtractMonths$1 as subtractMonths, subtractNanoseconds$1 as subtractNanoseconds, subtractSeconds$1 as subtractSeconds, subtractWeeks$1 as subtractWeeks, subtractYears$1 as subtractYears, toLocaleString$2 as toLocaleString, toLocaleStringParts$2 as toLocaleStringParts, toPlainDate$1 as toPlainDate, toPlainMonthDay$1 as toPlainMonthDay, toPlainTime$1 as toPlainTime, toPlainYearMonth$1 as toPlainYearMonth, toString$2 as toString, toZonedDateTime$1 as toZonedDateTime, until$2 as until, weekOfYear$1 as weekOfYear, withCalendar$1 as withCalendar, withDayOfMonth$1 as withDayOfMonth, withDayOfWeek$1 as withDayOfWeek, withDayOfYear$1 as withDayOfYear, withFields$1 as withFields, withPlainDate$1 as withPlainDate, withPlainTime$1 as withPlainTime, withWeekOfYear$1 as withWeekOfYear, yearOfWeek$1 as yearOfWeek } from "../chunks/funcApi.js";
@@ -0,0 +1,13 @@
"use strict";
require("../chunks/internal.cjs");
var funcApi = require("../chunks/funcApi.cjs");
exports.calendarId = funcApi.calendarId$4, exports.create = funcApi.create$6, exports.equals = funcApi.equals$6,
exports.fromFields = funcApi.fromFields$5, exports.fromString = funcApi.fromString$6,
exports.getFields = funcApi.getFields$5, exports.getISOFields = funcApi.getISOFields$5,
exports.isInstance = funcApi.isInstance$6, exports.rangeToLocaleString = funcApi.rangeToLocaleString$6,
exports.rangeToLocaleStringParts = funcApi.rangeToLocaleStringParts$6, exports.toLocaleString = funcApi.toLocaleString$6,
exports.toLocaleStringParts = funcApi.toLocaleStringParts$6, exports.toPlainDate = funcApi.toPlainDate$3,
exports.toString = funcApi.toString$6, exports.withFields = funcApi.withFields$5;
@@ -0,0 +1,57 @@
import { PlainMonthDayBranding, MonthDayFields, PlainMonthDayBag, MonthDayBag, IsoDateFields, EraYearOrYear, OverflowOptions, CalendarDisplayOptions, LocalesArg } from '../chunks/internal.js';
import { Record as Record$1 } from './plaindate.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof PlainMonthDayBranding;
/**
* @deprecated Use the calendarId() function instead.
*/
readonly calendar: string;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoYear: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMonth: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoDay: number;
};
type Fields = MonthDayFields;
type FromFields = PlainMonthDayBag;
type WithFields = MonthDayBag;
type ISOFields = IsoDateFields;
type ToPlainDateFields = EraYearOrYear;
type AssignmentOptions = OverflowOptions;
type ToStringOptions = CalendarDisplayOptions;
declare const create: (isoMonth: number, isoDay: number, calendar?: string, referenceIsoYear?: number) => Record;
declare function fromFields(fields: FromFields, options?: AssignmentOptions): Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (record: Record) => Fields;
declare const getISOFields: (record: Record) => ISOFields;
declare const calendarId: (record: Record) => string;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare const equals: (record0: Record, record1: Record) => boolean;
declare function toPlainDate(record: Record, fields: ToPlainDateFields): Record$1;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
export { type AssignmentOptions, type Fields, type FromFields, type ISOFields, type Record, type ToPlainDateFields, type ToStringOptions, type WithFields, calendarId, create, equals, fromFields, fromString, getFields, getISOFields, isInstance, rangeToLocaleString, rangeToLocaleStringParts, toLocaleString, toLocaleStringParts, toPlainDate, toString, withFields };
@@ -0,0 +1,57 @@
import { PlainMonthDayBranding, MonthDayFields, PlainMonthDayBag, MonthDayBag, IsoDateFields, EraYearOrYear, OverflowOptions, CalendarDisplayOptions, LocalesArg } from '../chunks/internal.js';
import { Record as Record$1 } from './plaindate.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof PlainMonthDayBranding;
/**
* @deprecated Use the calendarId() function instead.
*/
readonly calendar: string;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoYear: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMonth: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoDay: number;
};
type Fields = MonthDayFields;
type FromFields = PlainMonthDayBag;
type WithFields = MonthDayBag;
type ISOFields = IsoDateFields;
type ToPlainDateFields = EraYearOrYear;
type AssignmentOptions = OverflowOptions;
type ToStringOptions = CalendarDisplayOptions;
declare const create: (isoMonth: number, isoDay: number, calendar?: string, referenceIsoYear?: number) => Record;
declare function fromFields(fields: FromFields, options?: AssignmentOptions): Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (record: Record) => Fields;
declare const getISOFields: (record: Record) => ISOFields;
declare const calendarId: (record: Record) => string;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare const equals: (record0: Record, record1: Record) => boolean;
declare function toPlainDate(record: Record, fields: ToPlainDateFields): Record$1;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
export { type AssignmentOptions, type Fields, type FromFields, type ISOFields, type Record, type ToPlainDateFields, type ToStringOptions, type WithFields, calendarId, create, equals, fromFields, fromString, getFields, getISOFields, isInstance, rangeToLocaleString, rangeToLocaleStringParts, toLocaleString, toLocaleStringParts, toPlainDate, toString, withFields };
@@ -0,0 +1,3 @@
import "../chunks/internal.js";
export { calendarId$4 as calendarId, create$6 as create, equals$6 as equals, fromFields$5 as fromFields, fromString$6 as fromString, getFields$5 as getFields, getISOFields$5 as getISOFields, isInstance$6 as isInstance, rangeToLocaleString$6 as rangeToLocaleString, rangeToLocaleStringParts$6 as rangeToLocaleStringParts, toLocaleString$6 as toLocaleString, toLocaleStringParts$6 as toLocaleStringParts, toPlainDate$3 as toPlainDate, toString$6 as toString, withFields$5 as withFields } from "../chunks/funcApi.js";
@@ -0,0 +1,15 @@
"use strict";
require("../chunks/internal.cjs");
var funcApi = require("../chunks/funcApi.cjs");
exports.add = funcApi.add$4, exports.compare = funcApi.compare$4, exports.create = funcApi.create$4,
exports.equals = funcApi.equals$4, exports.fromFields = funcApi.fromFields$3, exports.fromString = funcApi.fromString$4,
exports.getFields = funcApi.getFields$3, exports.getISOFields = funcApi.getISOFields$3,
exports.isInstance = funcApi.isInstance$4, exports.rangeToLocaleString = funcApi.rangeToLocaleString$4,
exports.rangeToLocaleStringParts = funcApi.rangeToLocaleStringParts$4, exports.round = funcApi.round$3,
exports.since = funcApi.since$4, exports.subtract = funcApi.subtract$4, exports.toLocaleString = funcApi.toLocaleString$4,
exports.toLocaleStringParts = funcApi.toLocaleStringParts$4, exports.toPlainDateTime = funcApi.toPlainDateTime$2,
exports.toString = funcApi.toString$4, exports.toZonedDateTime = funcApi.toZonedDateTime$3,
exports.until = funcApi.until$4, exports.withFields = funcApi.withFields$3;
@@ -0,0 +1,76 @@
import { PlainTimeBranding, TimeFields, PlainTimeBag, TimeBag, IsoTimeFields, OverflowOptions, DiffOptions, TimeUnitName, RoundingOptions, TimeDisplayOptions, NumberSign, LocalesArg } from '../chunks/internal.js';
import { Record as Record$2 } from './duration.js';
import { Record as Record$1 } from './plaindate.js';
import { Record as Record$4 } from './plaindatetime.js';
import { Record as Record$3 } from './zoneddatetime.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
branding: typeof PlainTimeBranding;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoHour: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMinute: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoSecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMillisecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMicrosecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoNanosecond: number;
};
type Fields = TimeFields;
type FromFields = PlainTimeBag;
type WithFields = TimeBag;
type ISOFields = IsoTimeFields;
type AssignmentOptions = OverflowOptions;
type DifferenceOptions = DiffOptions<TimeUnitName>;
type RoundOptions = RoundingOptions<TimeUnitName>;
type ToStringOptions = TimeDisplayOptions;
type ToZonedDateTimeOptions = {
timeZone: string;
plainDate: Record$1;
};
declare const create: (isoHour?: number, isoMinute?: number, isoSecond?: number, isoMillisecond?: number, isoMicrosecond?: number, isoNanosecond?: number) => Record;
declare const fromFields: (fields: FromFields, options?: AssignmentOptions) => Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (record: Record) => Fields;
declare const getISOFields: (record: Record) => ISOFields;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare const add: (plainTimeRecord: Record, durationRecord: Record$2) => Record;
declare const subtract: (plainTimeRecord: Record, durationRecord: Record$2) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$2;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$2;
declare const round: (record: Record, options: TimeUnitName | RoundOptions) => Record;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare const toZonedDateTime: (plainTimeRecord: Record, options: ToZonedDateTimeOptions) => Record$3;
declare const toPlainDateTime: (plainTimeRecord: Record, plainDateRecord: Record$1) => Record$4;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
export { type AssignmentOptions, type DifferenceOptions, type Fields, type FromFields, type ISOFields, type Record, type RoundOptions, type ToStringOptions, type ToZonedDateTimeOptions, type WithFields, add, compare, create, equals, fromFields, fromString, getFields, getISOFields, isInstance, rangeToLocaleString, rangeToLocaleStringParts, round, since, subtract, toLocaleString, toLocaleStringParts, toPlainDateTime, toString, toZonedDateTime, until, withFields };
@@ -0,0 +1,76 @@
import { PlainTimeBranding, TimeFields, PlainTimeBag, TimeBag, IsoTimeFields, OverflowOptions, DiffOptions, TimeUnitName, RoundingOptions, TimeDisplayOptions, NumberSign, LocalesArg } from '../chunks/internal.js';
import { Record as Record$2 } from './duration.js';
import { Record as Record$1 } from './plaindate.js';
import { Record as Record$4 } from './plaindatetime.js';
import { Record as Record$3 } from './zoneddatetime.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
branding: typeof PlainTimeBranding;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoHour: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMinute: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoSecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMillisecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMicrosecond: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoNanosecond: number;
};
type Fields = TimeFields;
type FromFields = PlainTimeBag;
type WithFields = TimeBag;
type ISOFields = IsoTimeFields;
type AssignmentOptions = OverflowOptions;
type DifferenceOptions = DiffOptions<TimeUnitName>;
type RoundOptions = RoundingOptions<TimeUnitName>;
type ToStringOptions = TimeDisplayOptions;
type ToZonedDateTimeOptions = {
timeZone: string;
plainDate: Record$1;
};
declare const create: (isoHour?: number, isoMinute?: number, isoSecond?: number, isoMillisecond?: number, isoMicrosecond?: number, isoNanosecond?: number) => Record;
declare const fromFields: (fields: FromFields, options?: AssignmentOptions) => Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (record: Record) => Fields;
declare const getISOFields: (record: Record) => ISOFields;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare const add: (plainTimeRecord: Record, durationRecord: Record$2) => Record;
declare const subtract: (plainTimeRecord: Record, durationRecord: Record$2) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$2;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$2;
declare const round: (record: Record, options: TimeUnitName | RoundOptions) => Record;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare const toZonedDateTime: (plainTimeRecord: Record, options: ToZonedDateTimeOptions) => Record$3;
declare const toPlainDateTime: (plainTimeRecord: Record, plainDateRecord: Record$1) => Record$4;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
export { type AssignmentOptions, type DifferenceOptions, type Fields, type FromFields, type ISOFields, type Record, type RoundOptions, type ToStringOptions, type ToZonedDateTimeOptions, type WithFields, add, compare, create, equals, fromFields, fromString, getFields, getISOFields, isInstance, rangeToLocaleString, rangeToLocaleStringParts, round, since, subtract, toLocaleString, toLocaleStringParts, toPlainDateTime, toString, toZonedDateTime, until, withFields };
@@ -0,0 +1,3 @@
import "../chunks/internal.js";
export { add$4 as add, compare$4 as compare, create$4 as create, equals$4 as equals, fromFields$3 as fromFields, fromString$4 as fromString, getFields$3 as getFields, getISOFields$3 as getISOFields, isInstance$4 as isInstance, rangeToLocaleString$4 as rangeToLocaleString, rangeToLocaleStringParts$4 as rangeToLocaleStringParts, round$3 as round, since$4 as since, subtract$4 as subtract, toLocaleString$4 as toLocaleString, toLocaleStringParts$4 as toLocaleStringParts, toPlainDateTime$2 as toPlainDateTime, toString$4 as toString, toZonedDateTime$3 as toZonedDateTime, until$4 as until, withFields$3 as withFields } from "../chunks/funcApi.js";
@@ -0,0 +1,16 @@
"use strict";
require("../chunks/internal.cjs");
var funcApi = require("../chunks/funcApi.cjs");
exports.add = funcApi.add$5, exports.calendarId = funcApi.calendarId$3, exports.compare = funcApi.compare$5,
exports.create = funcApi.create$5, exports.daysInMonth = funcApi.daysInMonth$3,
exports.daysInYear = funcApi.daysInYear$3, exports.equals = funcApi.equals$5, exports.fromFields = funcApi.fromFields$4,
exports.fromString = funcApi.fromString$5, exports.getFields = funcApi.getFields$4,
exports.getISOFields = funcApi.getISOFields$4, exports.inLeapYear = funcApi.inLeapYear$3,
exports.isInstance = funcApi.isInstance$5, exports.monthsInYear = funcApi.monthsInYear$3,
exports.rangeToLocaleString = funcApi.rangeToLocaleString$5, exports.rangeToLocaleStringParts = funcApi.rangeToLocaleStringParts$5,
exports.since = funcApi.since$5, exports.subtract = funcApi.subtract$5, exports.toLocaleString = funcApi.toLocaleString$5,
exports.toLocaleStringParts = funcApi.toLocaleStringParts$5, exports.toPlainDate = funcApi.toPlainDate$2,
exports.toString = funcApi.toString$5, exports.until = funcApi.until$5, exports.withFields = funcApi.withFields$4;
@@ -0,0 +1,70 @@
import { PlainYearMonthBranding, YearMonthFields, PlainYearMonthBag, YearMonthBag, IsoDateFields, OverflowOptions, DiffOptions, YearMonthUnitName, CalendarDisplayOptions, NumberSign, LocalesArg } from '../chunks/internal.js';
import { Record as Record$1 } from './duration.js';
import { Record as Record$2 } from './plaindate.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof PlainYearMonthBranding;
/**
* @deprecated Use the calendarId() function instead.
*/
readonly calendar: string;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoYear: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMonth: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoDay: number;
};
type Fields = YearMonthFields;
type FromFields = PlainYearMonthBag;
type WithFields = YearMonthBag;
type ISOFields = IsoDateFields;
type ToPlainDateFields = {
day: number;
};
type AssignmentOptions = OverflowOptions;
type ArithmeticOptions = OverflowOptions;
type DifferenceOptions = DiffOptions<YearMonthUnitName>;
type ToStringOptions = CalendarDisplayOptions;
declare const create: (isoYear: number, isoMonth: number, calendar?: string, referenceIsoDay?: number) => Record;
declare function fromFields(fields: FromFields, options?: AssignmentOptions): Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (record: Record) => Fields;
declare const getISOFields: (record: Record) => ISOFields;
declare const calendarId: (record: Record) => string;
declare const daysInMonth: (record: Record) => number;
declare const daysInYear: (record: Record) => number;
declare const monthsInYear: (record: Record) => number;
declare const inLeapYear: (record: Record) => boolean;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare const add: (plainYearMonthFields: Record, durationRecord: Record$1, options?: ArithmeticOptions) => Record;
declare const subtract: (plainYearMonthFields: Record, durationRecord: Record$1, options?: ArithmeticOptions) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$1;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$1;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare function toPlainDate(record: Record, fields: ToPlainDateFields): Record$2;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
export { type ArithmeticOptions, type AssignmentOptions, type DifferenceOptions, type Fields, type FromFields, type ISOFields, type Record, type ToPlainDateFields, type ToStringOptions, type WithFields, add, calendarId, compare, create, daysInMonth, daysInYear, equals, fromFields, fromString, getFields, getISOFields, inLeapYear, isInstance, monthsInYear, rangeToLocaleString, rangeToLocaleStringParts, since, subtract, toLocaleString, toLocaleStringParts, toPlainDate, toString, until, withFields };
@@ -0,0 +1,70 @@
import { PlainYearMonthBranding, YearMonthFields, PlainYearMonthBag, YearMonthBag, IsoDateFields, OverflowOptions, DiffOptions, YearMonthUnitName, CalendarDisplayOptions, NumberSign, LocalesArg } from '../chunks/internal.js';
import { Record as Record$1 } from './duration.js';
import { Record as Record$2 } from './plaindate.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof PlainYearMonthBranding;
/**
* @deprecated Use the calendarId() function instead.
*/
readonly calendar: string;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoYear: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoMonth: number;
/**
* @deprecated Use the getISOFields() function instead.
*/
readonly isoDay: number;
};
type Fields = YearMonthFields;
type FromFields = PlainYearMonthBag;
type WithFields = YearMonthBag;
type ISOFields = IsoDateFields;
type ToPlainDateFields = {
day: number;
};
type AssignmentOptions = OverflowOptions;
type ArithmeticOptions = OverflowOptions;
type DifferenceOptions = DiffOptions<YearMonthUnitName>;
type ToStringOptions = CalendarDisplayOptions;
declare const create: (isoYear: number, isoMonth: number, calendar?: string, referenceIsoDay?: number) => Record;
declare function fromFields(fields: FromFields, options?: AssignmentOptions): Record;
declare const fromString: (s: string) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (record: Record) => Fields;
declare const getISOFields: (record: Record) => ISOFields;
declare const calendarId: (record: Record) => string;
declare const daysInMonth: (record: Record) => number;
declare const daysInYear: (record: Record) => number;
declare const monthsInYear: (record: Record) => number;
declare const inLeapYear: (record: Record) => boolean;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare const add: (plainYearMonthFields: Record, durationRecord: Record$1, options?: ArithmeticOptions) => Record;
declare const subtract: (plainYearMonthFields: Record, durationRecord: Record$1, options?: ArithmeticOptions) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$1;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$1;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare function toPlainDate(record: Record, fields: ToPlainDateFields): Record$2;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
export { type ArithmeticOptions, type AssignmentOptions, type DifferenceOptions, type Fields, type FromFields, type ISOFields, type Record, type ToPlainDateFields, type ToStringOptions, type WithFields, add, calendarId, compare, create, daysInMonth, daysInYear, equals, fromFields, fromString, getFields, getISOFields, inLeapYear, isInstance, monthsInYear, rangeToLocaleString, rangeToLocaleStringParts, since, subtract, toLocaleString, toLocaleStringParts, toPlainDate, toString, until, withFields };
@@ -0,0 +1,3 @@
import "../chunks/internal.js";
export { add$5 as add, calendarId$3 as calendarId, compare$5 as compare, create$5 as create, daysInMonth$3 as daysInMonth, daysInYear$3 as daysInYear, equals$5 as equals, fromFields$4 as fromFields, fromString$5 as fromString, getFields$4 as getFields, getISOFields$4 as getISOFields, inLeapYear$3 as inLeapYear, isInstance$5 as isInstance, monthsInYear$3 as monthsInYear, rangeToLocaleString$5 as rangeToLocaleString, rangeToLocaleStringParts$5 as rangeToLocaleStringParts, since$5 as since, subtract$5 as subtract, toLocaleString$5 as toLocaleString, toLocaleStringParts$5 as toLocaleStringParts, toPlainDate$2 as toPlainDate, toString$5 as toString, until$5 as until, withFields$4 as withFields } from "../chunks/funcApi.js";
@@ -0,0 +1,53 @@
"use strict";
require("../chunks/internal.cjs");
var funcApi = require("../chunks/funcApi.cjs");
exports.add = funcApi.add$1, exports.addDays = funcApi.addDays, exports.addHours = funcApi.addHours,
exports.addMicroseconds = funcApi.addMicroseconds, exports.addMilliseconds = funcApi.addMilliseconds,
exports.addMinutes = funcApi.addMinutes, exports.addMonths = funcApi.addMonths,
exports.addNanoseconds = funcApi.addNanoseconds, exports.addSeconds = funcApi.addSeconds,
exports.addWeeks = funcApi.addWeeks, exports.addYears = funcApi.addYears, exports.calendarId = funcApi.calendarId,
exports.compare = funcApi.compare$1, exports.create = funcApi.create$1, exports.dayOfWeek = funcApi.dayOfWeek,
exports.dayOfYear = funcApi.dayOfYear, exports.daysInMonth = funcApi.daysInMonth,
exports.daysInWeek = funcApi.daysInWeek, exports.daysInYear = funcApi.daysInYear,
exports.diffDays = funcApi.diffDays, exports.diffHours = funcApi.diffHours, exports.diffMicroseconds = funcApi.diffMicroseconds,
exports.diffMilliseconds = funcApi.diffMilliseconds, exports.diffMinutes = funcApi.diffMinutes,
exports.diffMonths = funcApi.diffMonths, exports.diffNanoseconds = funcApi.diffNanoseconds,
exports.diffSeconds = funcApi.diffSeconds, exports.diffWeeks = funcApi.diffWeeks,
exports.diffYears = funcApi.diffYears, exports.endOfDay = funcApi.endOfDay, exports.endOfHour = funcApi.endOfHour,
exports.endOfMicrosecond = funcApi.endOfMicrosecond, exports.endOfMillisecond = funcApi.endOfMillisecond,
exports.endOfMinute = funcApi.endOfMinute, exports.endOfMonth = funcApi.endOfMonth,
exports.endOfSecond = funcApi.endOfSecond, exports.endOfWeek = funcApi.endOfWeek,
exports.endOfYear = funcApi.endOfYear, exports.epochMicroseconds = funcApi.epochMicroseconds$1,
exports.epochMilliseconds = funcApi.epochMilliseconds$1, exports.epochNanoseconds = funcApi.epochNanoseconds$1,
exports.epochSeconds = funcApi.epochSeconds$1, exports.equals = funcApi.equals$1,
exports.fromFields = funcApi.fromFields, exports.fromString = funcApi.fromString$1,
exports.getFields = funcApi.getFields, exports.getISOFields = funcApi.getISOFields,
exports.hoursInDay = funcApi.hoursInDay, exports.inLeapYear = funcApi.inLeapYear,
exports.isInstance = funcApi.isInstance$1, exports.monthsInYear = funcApi.monthsInYear,
exports.offset = funcApi.offset, exports.offsetNanoseconds = funcApi.offsetNanoseconds,
exports.rangeToLocaleString = funcApi.rangeToLocaleString$1, exports.rangeToLocaleStringParts = funcApi.rangeToLocaleStringParts$1,
exports.round = funcApi.round$1, exports.roundToMonth = funcApi.roundToMonth, exports.roundToWeek = funcApi.roundToWeek,
exports.roundToYear = funcApi.roundToYear, exports.since = funcApi.since$1, exports.startOfDay = funcApi.startOfDay,
exports.startOfHour = funcApi.startOfHour, exports.startOfMicrosecond = funcApi.startOfMicrosecond,
exports.startOfMillisecond = funcApi.startOfMillisecond, exports.startOfMinute = funcApi.startOfMinute,
exports.startOfMonth = funcApi.startOfMonth, exports.startOfSecond = funcApi.startOfSecond,
exports.startOfWeek = funcApi.startOfWeek, exports.startOfYear = funcApi.startOfYear,
exports.subtract = funcApi.subtract$1, exports.subtractDays = funcApi.subtractDays,
exports.subtractHours = funcApi.subtractHours, exports.subtractMicroseconds = funcApi.subtractMicroseconds,
exports.subtractMilliseconds = funcApi.subtractMilliseconds, exports.subtractMinutes = funcApi.subtractMinutes,
exports.subtractMonths = funcApi.subtractMonths, exports.subtractNanoseconds = funcApi.subtractNanoseconds,
exports.subtractSeconds = funcApi.subtractSeconds, exports.subtractWeeks = funcApi.subtractWeeks,
exports.subtractYears = funcApi.subtractYears, exports.timeZoneId = funcApi.timeZoneId,
exports.toInstant = funcApi.toInstant, exports.toLocaleString = funcApi.toLocaleString$1,
exports.toLocaleStringParts = funcApi.toLocaleStringParts$1, exports.toPlainDate = funcApi.toPlainDate,
exports.toPlainDateTime = funcApi.toPlainDateTime, exports.toPlainMonthDay = funcApi.toPlainMonthDay,
exports.toPlainTime = funcApi.toPlainTime, exports.toPlainYearMonth = funcApi.toPlainYearMonth,
exports.toString = funcApi.toString$1, exports.until = funcApi.until$1, exports.weekOfYear = funcApi.weekOfYear,
exports.withCalendar = funcApi.withCalendar, exports.withDayOfMonth = funcApi.withDayOfMonth,
exports.withDayOfWeek = funcApi.withDayOfWeek, exports.withDayOfYear = funcApi.withDayOfYear,
exports.withFields = funcApi.withFields, exports.withPlainDate = funcApi.withPlainDate,
exports.withPlainTime = funcApi.withPlainTime, exports.withTimeZone = funcApi.withTimeZone,
exports.withWeekOfYear = funcApi.withWeekOfYear, exports.yearOfWeek = funcApi.yearOfWeek;
@@ -0,0 +1,142 @@
import { ZonedDateTimeBranding, BigNano, ZonedDateTimeFields, ZonedDateTimeBag, DateTimeBag, ZonedIsoFields, ZonedFieldOptions, OverflowOptions, DiffOptions, UnitName, RoundingOptions, DayTimeUnitName, ZonedDateTimeDisplayOptions, NumberSign, LocalesArg, DateSlots, IsoDateFields, RoundingMathOptions, ZonedDateTimeSlots, Marker } from '../chunks/internal.js';
import * as temporal_spec from 'temporal-spec';
import { Record as Record$3 } from './duration.js';
import { Record as Record$4 } from './instant.js';
import { Record as Record$1 } from './plaindate.js';
import { Record as Record$5 } from './plaindatetime.js';
import { Record as Record$7 } from './plainmonthday.js';
import { Record as Record$2 } from './plaintime.js';
import { Record as Record$6 } from './plainyearmonth.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof ZonedDateTimeBranding;
/**
* @deprecated Use the calendarId() function instead.
*/
readonly calendar: string;
/**
* @deprecated Use the timeZoneId() function instead.
*/
readonly timeZone: string;
/**
* @deprecated Use the epochNanoseconds() function instead.
*/
readonly epochNanoseconds: BigNano;
};
type Fields = ZonedDateTimeFields;
type FromFields = ZonedDateTimeBag;
type WithFields = DateTimeBag;
type ISOFields = ZonedIsoFields;
type AssignmentOptions = ZonedFieldOptions;
type ArithmeticOptions = OverflowOptions;
type DifferenceOptions = DiffOptions<UnitName>;
type RoundOptions = RoundingOptions<DayTimeUnitName>;
type ToStringOptions = ZonedDateTimeDisplayOptions;
declare const create: (epochNanoseconds: bigint, timeZone: string, calendar?: string) => Record;
declare function fromFields(fields: FromFields, options?: AssignmentOptions): Record;
declare const fromString: (s: string, options?: AssignmentOptions) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (key: Record) => ZonedDateTimeFields;
declare const getISOFields: (record: Record) => ISOFields;
declare const calendarId: (record: Record) => string;
declare function timeZoneId(record: Record): string;
declare const epochSeconds: (record: Record) => number;
declare const epochMilliseconds: (record: Record) => number;
declare const epochMicroseconds: (record: Record) => bigint;
declare const epochNanoseconds: (record: Record) => bigint;
declare function offsetNanoseconds(record: Record): number;
declare function offset(record: Record): string;
declare const dayOfWeek: (record: Record) => number;
declare const daysInWeek: (record: Record) => number;
declare const weekOfYear: (record: Record) => number | undefined;
declare const yearOfWeek: (record: Record) => number | undefined;
declare const dayOfYear: (record: Record) => number;
declare const daysInMonth: (record: Record) => number;
declare const daysInYear: (record: Record) => number;
declare const monthsInYear: (record: Record) => number;
declare const inLeapYear: (record: Record) => boolean;
declare const hoursInDay: (record: Record) => number;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare function withCalendar(record: Record, calendar: string): Record;
declare function withTimeZone(record: Record, timeZone: string): Record;
declare const withPlainDate: (zonedDateTimeRecord: Record, plainDateRecord: Record$1) => Record;
declare const withPlainTime: (zonedDateTimeRecord: Record, plainTimeRecord?: Record$2) => Record;
declare const add: (zonedDateTimeRecord: Record, durationRecord: Record$3, options?: ArithmeticOptions) => Record;
declare const subtract: (zonedDateTimeRecord: Record, durationRecord: Record$3, options?: ArithmeticOptions) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$3;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$3;
declare const round: (record: Record, options: DayTimeUnitName | RoundOptions) => Record;
declare const startOfDay: (record: Record) => Record;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare const toInstant: (record: Record) => Record$4;
declare const toPlainDateTime: (record: Record) => Record$5;
declare const toPlainDate: (record: Record) => Record$1;
declare const toPlainTime: (record: Record) => Record$2;
declare function toPlainYearMonth(record: Record): Record$6;
declare function toPlainMonthDay(record: Record): Record$7;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
declare const withDayOfYear: <S extends DateSlots>(record: Record, dayOfYear: number, options?: OverflowOptions | undefined) => Record;
declare const withDayOfMonth: <S extends DateSlots>(record: Record, day: number, options?: OverflowOptions | undefined) => Record;
declare const withDayOfWeek: <S extends IsoDateFields>(record: Record, dayOfWeek: number, options?: OverflowOptions | undefined) => Record;
declare const withWeekOfYear: <S extends DateSlots>(record: Record, weekOfYear: number, options?: OverflowOptions | undefined) => Record;
declare const addYears: <S extends DateSlots>(record: Record, years: number, options?: OverflowOptions | undefined) => Record;
declare const addMonths: <S extends DateSlots>(record: Record, months: number, options?: OverflowOptions | undefined) => Record;
declare const addWeeks: <F extends IsoDateFields>(record: Record, weeks: number) => Record;
declare const addDays: <F extends IsoDateFields>(record: Record, weeks: number) => Record;
declare const addHours: (record: Record, units: number) => Record;
declare const addMinutes: (record: Record, units: number) => Record;
declare const addSeconds: (record: Record, units: number) => Record;
declare const addMilliseconds: (record: Record, units: number) => Record;
declare const addMicroseconds: (record: Record, units: number) => Record;
declare const addNanoseconds: (record: Record, units: number) => Record;
declare const subtractYears: <S extends DateSlots>(slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMonths: <S extends DateSlots>(slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractWeeks: <F extends IsoDateFields>(slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractDays: <F extends IsoDateFields>(slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractHours: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMinutes: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractSeconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMilliseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMicroseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractNanoseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const roundToYear: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToMonth: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToWeek: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const startOfYear: (record: Record) => Record;
declare const startOfMonth: (record: Record) => Record;
declare const startOfWeek: (record: Record) => Record;
declare const startOfHour: (record: Record) => Record;
declare const startOfMinute: (record: Record) => Record;
declare const startOfSecond: (record: Record) => Record;
declare const startOfMillisecond: (record: Record) => Record;
declare const startOfMicrosecond: (record: Record) => Record;
declare const endOfYear: (record: Record) => Record;
declare const endOfMonth: (record: Record) => Record;
declare const endOfWeek: (record: Record) => Record;
declare const endOfDay: (record: Record) => Record;
declare const endOfHour: (record: Record) => Record;
declare const endOfMinute: (record: Record) => Record;
declare const endOfSecond: (record: Record) => Record;
declare const endOfMillisecond: (record: Record) => Record;
declare const endOfMicrosecond: (record: Record) => Record;
declare const diffYears: (record0: ZonedDateTimeSlots, record1: ZonedDateTimeSlots, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMonths: (record0: ZonedDateTimeSlots, record1: ZonedDateTimeSlots, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffWeeks: (record0: ZonedDateTimeSlots, record1: ZonedDateTimeSlots, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffDays: (record0: ZonedDateTimeSlots, record1: ZonedDateTimeSlots, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffHours: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMinutes: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffSeconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMilliseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMicroseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffNanoseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
export { type ArithmeticOptions, type AssignmentOptions, type DifferenceOptions, type Fields, type FromFields, type ISOFields, type Record, type RoundOptions, type ToStringOptions, type WithFields, add, addDays, addHours, addMicroseconds, addMilliseconds, addMinutes, addMonths, addNanoseconds, addSeconds, addWeeks, addYears, calendarId, compare, create, dayOfWeek, dayOfYear, daysInMonth, daysInWeek, daysInYear, diffDays, diffHours, diffMicroseconds, diffMilliseconds, diffMinutes, diffMonths, diffNanoseconds, diffSeconds, diffWeeks, diffYears, endOfDay, endOfHour, endOfMicrosecond, endOfMillisecond, endOfMinute, endOfMonth, endOfSecond, endOfWeek, endOfYear, epochMicroseconds, epochMilliseconds, epochNanoseconds, epochSeconds, equals, fromFields, fromString, getFields, getISOFields, hoursInDay, inLeapYear, isInstance, monthsInYear, offset, offsetNanoseconds, rangeToLocaleString, rangeToLocaleStringParts, round, roundToMonth, roundToWeek, roundToYear, since, startOfDay, startOfHour, startOfMicrosecond, startOfMillisecond, startOfMinute, startOfMonth, startOfSecond, startOfWeek, startOfYear, subtract, subtractDays, subtractHours, subtractMicroseconds, subtractMilliseconds, subtractMinutes, subtractMonths, subtractNanoseconds, subtractSeconds, subtractWeeks, subtractYears, timeZoneId, toInstant, toLocaleString, toLocaleStringParts, toPlainDate, toPlainDateTime, toPlainMonthDay, toPlainTime, toPlainYearMonth, toString, until, weekOfYear, withCalendar, withDayOfMonth, withDayOfWeek, withDayOfYear, withFields, withPlainDate, withPlainTime, withTimeZone, withWeekOfYear, yearOfWeek };
@@ -0,0 +1,142 @@
import { ZonedDateTimeBranding, BigNano, ZonedDateTimeFields, ZonedDateTimeBag, DateTimeBag, ZonedIsoFields, ZonedFieldOptions, OverflowOptions, DiffOptions, UnitName, RoundingOptions, DayTimeUnitName, ZonedDateTimeDisplayOptions, NumberSign, LocalesArg, DateSlots, IsoDateFields, RoundingMathOptions, ZonedDateTimeSlots, Marker } from '../chunks/internal.js';
import * as temporal_spec from 'temporal-spec';
import { Record as Record$3 } from './duration.js';
import { Record as Record$4 } from './instant.js';
import { Record as Record$1 } from './plaindate.js';
import { Record as Record$5 } from './plaindatetime.js';
import { Record as Record$7 } from './plainmonthday.js';
import { Record as Record$2 } from './plaintime.js';
import { Record as Record$6 } from './plainyearmonth.js';
type Record = {
/**
* @deprecated Use the isInstance() function instead.
*/
readonly branding: typeof ZonedDateTimeBranding;
/**
* @deprecated Use the calendarId() function instead.
*/
readonly calendar: string;
/**
* @deprecated Use the timeZoneId() function instead.
*/
readonly timeZone: string;
/**
* @deprecated Use the epochNanoseconds() function instead.
*/
readonly epochNanoseconds: BigNano;
};
type Fields = ZonedDateTimeFields;
type FromFields = ZonedDateTimeBag;
type WithFields = DateTimeBag;
type ISOFields = ZonedIsoFields;
type AssignmentOptions = ZonedFieldOptions;
type ArithmeticOptions = OverflowOptions;
type DifferenceOptions = DiffOptions<UnitName>;
type RoundOptions = RoundingOptions<DayTimeUnitName>;
type ToStringOptions = ZonedDateTimeDisplayOptions;
declare const create: (epochNanoseconds: bigint, timeZone: string, calendar?: string) => Record;
declare function fromFields(fields: FromFields, options?: AssignmentOptions): Record;
declare const fromString: (s: string, options?: AssignmentOptions) => Record;
declare function isInstance(record: any): record is Record;
declare const getFields: (key: Record) => ZonedDateTimeFields;
declare const getISOFields: (record: Record) => ISOFields;
declare const calendarId: (record: Record) => string;
declare function timeZoneId(record: Record): string;
declare const epochSeconds: (record: Record) => number;
declare const epochMilliseconds: (record: Record) => number;
declare const epochMicroseconds: (record: Record) => bigint;
declare const epochNanoseconds: (record: Record) => bigint;
declare function offsetNanoseconds(record: Record): number;
declare function offset(record: Record): string;
declare const dayOfWeek: (record: Record) => number;
declare const daysInWeek: (record: Record) => number;
declare const weekOfYear: (record: Record) => number | undefined;
declare const yearOfWeek: (record: Record) => number | undefined;
declare const dayOfYear: (record: Record) => number;
declare const daysInMonth: (record: Record) => number;
declare const daysInYear: (record: Record) => number;
declare const monthsInYear: (record: Record) => number;
declare const inLeapYear: (record: Record) => boolean;
declare const hoursInDay: (record: Record) => number;
declare function withFields(record: Record, fields: WithFields, options?: AssignmentOptions): Record;
declare function withCalendar(record: Record, calendar: string): Record;
declare function withTimeZone(record: Record, timeZone: string): Record;
declare const withPlainDate: (zonedDateTimeRecord: Record, plainDateRecord: Record$1) => Record;
declare const withPlainTime: (zonedDateTimeRecord: Record, plainTimeRecord?: Record$2) => Record;
declare const add: (zonedDateTimeRecord: Record, durationRecord: Record$3, options?: ArithmeticOptions) => Record;
declare const subtract: (zonedDateTimeRecord: Record, durationRecord: Record$3, options?: ArithmeticOptions) => Record;
declare const until: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$3;
declare const since: (record0: Record, record1: Record, options?: DifferenceOptions) => Record$3;
declare const round: (record: Record, options: DayTimeUnitName | RoundOptions) => Record;
declare const startOfDay: (record: Record) => Record;
declare const equals: (record0: Record, record1: Record) => boolean;
declare const compare: (record0: Record, record1: Record) => NumberSign;
declare const toInstant: (record: Record) => Record$4;
declare const toPlainDateTime: (record: Record) => Record$5;
declare const toPlainDate: (record: Record) => Record$1;
declare const toPlainTime: (record: Record) => Record$2;
declare function toPlainYearMonth(record: Record): Record$6;
declare function toPlainMonthDay(record: Record): Record$7;
declare function toLocaleString(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function toLocaleStringParts(record: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): Intl.DateTimeFormatPart[];
declare function rangeToLocaleString(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): string;
declare function rangeToLocaleStringParts(record0: Record, record1: Record, locales?: LocalesArg, options?: Intl.DateTimeFormatOptions): ReturnType<Intl.DateTimeFormat['formatRangeToParts']>;
declare const toString: (record: Record, options?: ToStringOptions) => string;
declare const withDayOfYear: <S extends DateSlots>(record: Record, dayOfYear: number, options?: OverflowOptions | undefined) => Record;
declare const withDayOfMonth: <S extends DateSlots>(record: Record, day: number, options?: OverflowOptions | undefined) => Record;
declare const withDayOfWeek: <S extends IsoDateFields>(record: Record, dayOfWeek: number, options?: OverflowOptions | undefined) => Record;
declare const withWeekOfYear: <S extends DateSlots>(record: Record, weekOfYear: number, options?: OverflowOptions | undefined) => Record;
declare const addYears: <S extends DateSlots>(record: Record, years: number, options?: OverflowOptions | undefined) => Record;
declare const addMonths: <S extends DateSlots>(record: Record, months: number, options?: OverflowOptions | undefined) => Record;
declare const addWeeks: <F extends IsoDateFields>(record: Record, weeks: number) => Record;
declare const addDays: <F extends IsoDateFields>(record: Record, weeks: number) => Record;
declare const addHours: (record: Record, units: number) => Record;
declare const addMinutes: (record: Record, units: number) => Record;
declare const addSeconds: (record: Record, units: number) => Record;
declare const addMilliseconds: (record: Record, units: number) => Record;
declare const addMicroseconds: (record: Record, units: number) => Record;
declare const addNanoseconds: (record: Record, units: number) => Record;
declare const subtractYears: <S extends DateSlots>(slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMonths: <S extends DateSlots>(slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractWeeks: <F extends IsoDateFields>(slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractDays: <F extends IsoDateFields>(slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractHours: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMinutes: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractSeconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMilliseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractMicroseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const subtractNanoseconds: (slots: Record, units: number, options?: OverflowOptions | undefined) => Record;
declare const roundToYear: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToMonth: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const roundToWeek: (record: Record, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => Record;
declare const startOfYear: (record: Record) => Record;
declare const startOfMonth: (record: Record) => Record;
declare const startOfWeek: (record: Record) => Record;
declare const startOfHour: (record: Record) => Record;
declare const startOfMinute: (record: Record) => Record;
declare const startOfSecond: (record: Record) => Record;
declare const startOfMillisecond: (record: Record) => Record;
declare const startOfMicrosecond: (record: Record) => Record;
declare const endOfYear: (record: Record) => Record;
declare const endOfMonth: (record: Record) => Record;
declare const endOfWeek: (record: Record) => Record;
declare const endOfDay: (record: Record) => Record;
declare const endOfHour: (record: Record) => Record;
declare const endOfMinute: (record: Record) => Record;
declare const endOfSecond: (record: Record) => Record;
declare const endOfMillisecond: (record: Record) => Record;
declare const endOfMicrosecond: (record: Record) => Record;
declare const diffYears: (record0: ZonedDateTimeSlots, record1: ZonedDateTimeSlots, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMonths: (record0: ZonedDateTimeSlots, record1: ZonedDateTimeSlots, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffWeeks: (record0: ZonedDateTimeSlots, record1: ZonedDateTimeSlots, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffDays: (record0: ZonedDateTimeSlots, record1: ZonedDateTimeSlots, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffHours: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMinutes: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffSeconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMilliseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffMicroseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
declare const diffNanoseconds: (record0: Marker, record1: Marker, options?: temporal_spec.Temporal.RoundingMode | RoundingMathOptions | undefined) => number;
export { type ArithmeticOptions, type AssignmentOptions, type DifferenceOptions, type Fields, type FromFields, type ISOFields, type Record, type RoundOptions, type ToStringOptions, type WithFields, add, addDays, addHours, addMicroseconds, addMilliseconds, addMinutes, addMonths, addNanoseconds, addSeconds, addWeeks, addYears, calendarId, compare, create, dayOfWeek, dayOfYear, daysInMonth, daysInWeek, daysInYear, diffDays, diffHours, diffMicroseconds, diffMilliseconds, diffMinutes, diffMonths, diffNanoseconds, diffSeconds, diffWeeks, diffYears, endOfDay, endOfHour, endOfMicrosecond, endOfMillisecond, endOfMinute, endOfMonth, endOfSecond, endOfWeek, endOfYear, epochMicroseconds, epochMilliseconds, epochNanoseconds, epochSeconds, equals, fromFields, fromString, getFields, getISOFields, hoursInDay, inLeapYear, isInstance, monthsInYear, offset, offsetNanoseconds, rangeToLocaleString, rangeToLocaleStringParts, round, roundToMonth, roundToWeek, roundToYear, since, startOfDay, startOfHour, startOfMicrosecond, startOfMillisecond, startOfMinute, startOfMonth, startOfSecond, startOfWeek, startOfYear, subtract, subtractDays, subtractHours, subtractMicroseconds, subtractMilliseconds, subtractMinutes, subtractMonths, subtractNanoseconds, subtractSeconds, subtractWeeks, subtractYears, timeZoneId, toInstant, toLocaleString, toLocaleStringParts, toPlainDate, toPlainDateTime, toPlainMonthDay, toPlainTime, toPlainYearMonth, toString, until, weekOfYear, withCalendar, withDayOfMonth, withDayOfWeek, withDayOfYear, withFields, withPlainDate, withPlainTime, withTimeZone, withWeekOfYear, yearOfWeek };
@@ -0,0 +1,3 @@
import "../chunks/internal.js";
export { add$1 as add, addDays, addHours, addMicroseconds, addMilliseconds, addMinutes, addMonths, addNanoseconds, addSeconds, addWeeks, addYears, calendarId, compare$1 as compare, create$1 as create, dayOfWeek, dayOfYear, daysInMonth, daysInWeek, daysInYear, diffDays, diffHours, diffMicroseconds, diffMilliseconds, diffMinutes, diffMonths, diffNanoseconds, diffSeconds, diffWeeks, diffYears, endOfDay, endOfHour, endOfMicrosecond, endOfMillisecond, endOfMinute, endOfMonth, endOfSecond, endOfWeek, endOfYear, epochMicroseconds$1 as epochMicroseconds, epochMilliseconds$1 as epochMilliseconds, epochNanoseconds$1 as epochNanoseconds, epochSeconds$1 as epochSeconds, equals$1 as equals, fromFields, fromString$1 as fromString, getFields, getISOFields, hoursInDay, inLeapYear, isInstance$1 as isInstance, monthsInYear, offset, offsetNanoseconds, rangeToLocaleString$1 as rangeToLocaleString, rangeToLocaleStringParts$1 as rangeToLocaleStringParts, round$1 as round, roundToMonth, roundToWeek, roundToYear, since$1 as since, startOfDay, startOfHour, startOfMicrosecond, startOfMillisecond, startOfMinute, startOfMonth, startOfSecond, startOfWeek, startOfYear, subtract$1 as subtract, subtractDays, subtractHours, subtractMicroseconds, subtractMilliseconds, subtractMinutes, subtractMonths, subtractNanoseconds, subtractSeconds, subtractWeeks, subtractYears, timeZoneId, toInstant, toLocaleString$1 as toLocaleString, toLocaleStringParts$1 as toLocaleStringParts, toPlainDate, toPlainDateTime, toPlainMonthDay, toPlainTime, toPlainYearMonth, toString$1 as toString, until$1 as until, weekOfYear, withCalendar, withDayOfMonth, withDayOfWeek, withDayOfYear, withFields, withPlainDate, withPlainTime, withTimeZone, withWeekOfYear, yearOfWeek } from "../chunks/funcApi.js";
@@ -0,0 +1,11 @@
"use strict";
var classApi = require("./chunks/classApi.cjs"), internal = require("./chunks/internal.cjs");
Object.defineProperties(globalThis, internal.createPropDescriptors({
Temporal: classApi.Temporal
})), Object.defineProperties(Intl, internal.createPropDescriptors({
DateTimeFormat: classApi.DateTimeFormat
})), Object.defineProperties(Date.prototype, internal.createPropDescriptors({
toTemporalInstant: classApi.toTemporalInstant
}));
@@ -0,0 +1 @@
export * from 'temporal-spec/global';
@@ -0,0 +1 @@
export * from 'temporal-spec/global';
@@ -0,0 +1,11 @@
import { Temporal as Un, DateTimeFormat as Xn, toTemporalInstant as tj } from "./chunks/classApi.js";
import { createPropDescriptors as n } from "./chunks/internal.js";
Object.defineProperties(globalThis, n({
Temporal: Un
})), Object.defineProperties(Intl, n({
DateTimeFormat: Xn
})), Object.defineProperties(Date.prototype, n({
toTemporalInstant: tj
}));
File diff suppressed because it is too large. Load diff
@@ -0,0 +1 @@
!function(){"use strict";function n(n,r,e,o,i){return t(r,((n,t)=>{const r=n[t];if(void 0===r)throw new TypeError(Uo(t));return r})(n,r),e,o,i)}function t(n,t,r,e,o,i){const u=b(t,r,e);if(o&&t!==u)throw new RangeError(Ao(n,t,r,e,i));return u}function r(n){return null!==n&&/object|function/.test(typeof n)}function e(n,t=Map){const r=new t;return(t,...e)=>{if(r.has(t))return r.get(t);const o=n(t,...e);return r.set(t,o),o}}function o(n){return i({name:n},1)}function i(n,t){return a((n=>({value:n,configurable:1,writable:!t})),n)}function u(n){return a((n=>({get:n,configurable:1})),n)}function c(n){return{[Symbol.toStringTag]:{value:n,configurable:1}}}function s(n,t){const r={};let e=n.length;for(const o of t)r[n[--e]]=o;return r}function a(n,t,r){const e={};for(const o in t)e[o]=n(t[o],o,r);return e}function f(n,t,r){const e={};for(let o=0;o<t.length;o++){const i=t[o];e[i]=n(i,o,r)}return e}function h(n,t,r){const e={};for(let o=0;o<n.length;o++)e[t[o]]=r[n[o]];return e}function l(n,t){const r=Object.create(null);for(const e of n)r[e]=t[e];return r}function d(n,t){for(const r of t)if(r in n)return 1;return 0}function w(n,t,r){for(const e of n)if(t[e]!==r[e])return 0;return 1}function m(n,t,r){const e={...r};for(let r=0;r<t;r++)e[n[r]]=0;return e}function g(n,...t){return(...r)=>n(...t,...r)}function y(n){return n[0].toUpperCase()+n.substring(1)}function v(n){return n.slice().sort()}function p(n,t){return String(t).padStart(n,"0")}function M(n,t){return Math.sign(n-t)}function b(n,t,r){return Math.min(Math.max(n,t),r)}function E(n,t){return[Math.floor(n/t),R(n,t)]}function R(n,t){return(n%t+t)%t}function I(n,t){return[O(n,t),T(n,t)]}function O(n,t){return Math.trunc(n/t)||0}function T(n,t){return n%t||0}function S(n){return.5===Math.abs(n%1)}function P(n,t,r){let e=0,o=0;for(let i=0;i<=t;i++){const t=n[r[i]],u=Fi[i],c=ki/u,[s,a]=I(t,c);e+=a*u,o+=s}const[i,u]=I(e,ki);return[o+i,u]}function D(n,t,r){const e={};for(let o=t;o>=0;o--){const t=Fi[o];e[r[o]]=O(n,t),n=T(n,t)}return e}function N(n,t){let[r,e]=I(t,ki),o=n+r;const i=Math.sign(o);return i&&i===-Math.sign(e)&&(o-=i,e+=i*ki),[o,e]}function Y(n,t,r=1){return N(n[0]+t[0]*r,n[1]+t[1]*r)}function j(n,t){return N(n[0],n[1]+t)}function C(n,t){return Y(t,n,-1)}function Z(n,t){return M(n[0],t[0])||M(n[1],t[1])}function $(n,t,r){return-1===Z(n,t)||1===Z(n,r)}function k(n,t=1){const r=BigInt(ki/t);return[Number(n/r),Number(n%r)*t]}function F(n,t=1){const r=ki/t,[e,o]=I(n,r);return[e,o*t]}function L(n,t=1,r){const[e,o]=n,[i,u]=I(o,t);return e*(ki/t)+(i+(r?u/t:0))}function W(n,t,r=E){const[e,o]=n,[i,u]=r(o,t);return[e*(ki/t)+i,u]}function A(n){if(void 0!==n)return U(n)}function B(n){return _(U(n))}function U(n){return H(Ai(n))}function q(n,t){if(null==t)throw new RangeError(Uo(n));return t}function x(n){if(!r(n))throw new TypeError(Wo);return n}function J(n,t,r=n){if(typeof t!==n)throw new TypeError(Bo(r,t));return t}function H(n,t="number"){if(!Number.isInteger(n))throw new RangeError(Co(t,n));return n||0}function _(n,t="number"){if(n<=0)throw new RangeError(Zo(t,n));return n}function z(n){if("symbol"==typeof n)throw new TypeError(Lo);return String(n)}function G(n,t){return r(n)?String(n):Li(n,t)}function V(n){if("string"==typeof n)return BigInt(n);if("bigint"!=typeof n)throw new TypeError(Fo(n));return n}function K(n,t="number"){if("bigint"==typeof n)throw new TypeError(ko(t));if(n=Number(n),!Number.isFinite(n))throw new RangeError($o(t,n));return n}function Q(n,t){return Math.trunc(K(n,t))||0}function X(n,t){return H(K(n,t),t)}function nn(n,t){return _(Q(n,t),t)}function tn(t){return n(t,"isoYear",ju,Yu,1),t.isoYear===ju?n(t,"isoMonth",4,12,1):t.isoYear===Yu&&n(t,"isoMonth",1,9,1),t}function rn(n){return en({...n,...Ou,isoHour:12}),n}function en(t){const r=n(t,"isoYear",ju,Yu,1),e=r===ju?1:r===Yu?-1:0;return e&&on(fn({...t,isoDay:t.isoDay+e,isoNanosecond:t.isoNanosecond-e})),t}function on(n){if(!n||$(n,Nu,Du))throw new RangeError(di);return n}function un(n){return P(n,5,pu)[1]}function cn(n){const[t,r]=E(n,ki);return[D(r,5,pu),t]}function sn(n){return W(n,Ci)}function an(n){return dn(n.isoYear,n.isoMonth,n.isoDay,n.isoHour,n.isoMinute,n.isoSecond,n.isoMillisecond)}function fn(n){const t=an(n);if(void 0!==t){const[r,e]=I(t,Di);return[r,e*ji+(n.isoMicrosecond||0)*Yi+(n.isoNanosecond||0)]}}function hn(n,t){const[r,e]=cn(un(n)-t);return on(fn({...n,isoDay:n.isoDay+e,...r}))}function ln(...n){return dn(...n)/Ni}function dn(...n){const[t,r]=wn(...n),e=t.valueOf();if(!isNaN(e))return e-r*Di}function wn(n,t=1,r=1,e=0,o=0,i=0,u=0){const c=n===ju?1:n===Yu?-1:0,s=new Date;return s.setUTCHours(e,o,i,u),s.setUTCFullYear(n,t-1,r+c),[s,c]}function mn(n,t){let[r,e]=j(n,t);e<0&&(e+=ki,r-=1);const[o,i]=E(e,ji),[u,c]=E(i,Yi);return gn(r*Di+o,u,c)}function gn(n,t=0,r=0){const e=Math.ceil(Math.max(0,Math.abs(n)-Pu)/Di)*Math.sign(n),o=new Date(n-e*Di);return s(bu,[o.getUTCFullYear(),o.getUTCMonth()+1,o.getUTCDate()+e,o.getUTCHours(),o.getUTCMinutes(),o.getUTCSeconds(),o.getUTCMillisecondsLine truncated
@@ -0,0 +1,5 @@
"use strict";
var classApi = require("./chunks/classApi.cjs");
exports.Intl = classApi.IntlExtended, exports.Temporal = classApi.Temporal, exports.toTemporalInstant = classApi.toTemporalInstant;
@@ -0,0 +1 @@
export * from 'temporal-spec';
@@ -0,0 +1 @@
export * from 'temporal-spec';
@@ -0,0 +1 @@
export { IntlExtended as Intl, Temporal, toTemporalInstant } from "./chunks/classApi.js";
@@ -0,0 +1,5 @@
"use strict";
var classApi = require("./chunks/classApi.cjs");
exports.Intl = classApi.IntlExtended, exports.Temporal = classApi.Temporal, exports.toTemporalInstant = classApi.toTemporalInstant;
@@ -0,0 +1 @@
export * from 'temporal-spec';
@@ -0,0 +1 @@
export * from 'temporal-spec';
@@ -0,0 +1 @@
export { IntlExtended as Intl, Temporal, toTemporalInstant } from "./chunks/classApi.js";
@@ -0,0 +1,103 @@
{
"name": "temporal-polyfill",
"version": "0.3.2",
"title": "Temporal Polyfill",
"description": "A lightweight polyfill for Temporal, successor to the JavaScript Date object",
"author": {
"name": "Adam Shaw",
"email": "arshaw@users.noreply.github.com",
"url": "http://arshaw.com/"
},
"contributors": [
{
"name": "Ishaan Bharal",
"email": "ishbharal@gmail.com"
}
],
"license": "MIT",
"copyright": "2024 Adam Shaw",
"repository": {
"type": "git",
"url": "https://github.com/fullcalendar/temporal-polyfill.git"
},
"type": "module",
"dependencies": {
"temporal-spec": "0.3.1"
},
"main": "./index.cjs",
"types": "./index.d.ts",
"module": "./index.js",
"exports": {
".": {
"module-sync": "./index.js",
"require": "./index.cjs",
"import": "./index.js"
},
"./impl": {
"module-sync": "./impl.js",
"require": "./impl.cjs",
"import": "./impl.js"
},
"./global": {
"module-sync": "./global.esm.js",
"require": "./global.cjs",
"import": {
"types": "./global.d.ts",
"default": "./global.esm.js"
}
},
"./fns/instant": {
"module-sync": "./fns/instant.js",
"require": "./fns/instant.cjs",
"import": "./fns/instant.js"
},
"./fns/zoneddatetime": {
"module-sync": "./fns/zoneddatetime.js",
"require": "./fns/zoneddatetime.cjs",
"import": "./fns/zoneddatetime.js"
},
"./fns/plaindatetime": {
"module-sync": "./fns/plaindatetime.js",
"require": "./fns/plaindatetime.cjs",
"import": "./fns/plaindatetime.js"
},
"./fns/plaindate": {
"module-sync": "./fns/plaindate.js",
"require": "./fns/plaindate.cjs",
"import": "./fns/plaindate.js"
},
"./fns/plaintime": {
"module-sync": "./fns/plaintime.js",
"require": "./fns/plaintime.cjs",
"import": "./fns/plaintime.js"
},
"./fns/plainyearmonth": {
"module-sync": "./fns/plainyearmonth.js",
"require": "./fns/plainyearmonth.cjs",
"import": "./fns/plainyearmonth.js"
},
"./fns/plainmonthday": {
"module-sync": "./fns/plainmonthday.js",
"require": "./fns/plainmonthday.cjs",
"import": "./fns/plainmonthday.js"
},
"./fns/duration": {
"module-sync": "./fns/duration.js",
"require": "./fns/duration.cjs",
"import": "./fns/duration.js"
},
"./fns/now": {
"module-sync": "./fns/now.js",
"require": "./fns/now.cjs",
"import": "./fns/now.js"
}
},
"jsdelivr": "./global.min.js",
"unpkg": "./global.min.js",
"sideEffects": [
"./global.cjs",
"./global.esm.js",
"./global.js",
"./global.min.js"
]
}
+1
View File
@@ -0,0 +1 @@
../../temporal-spec@0.3.1/node_modules/temporal-spec