!function() {
"use strict";
function clampProp(props, propName, min, max, overflow) {
return clampEntity(propName, ((props, propName) => {
const propVal = props[propName];
if (void 0 === propVal) {
throw new TypeError(missingField(propName));
}
return propVal;
})(props, propName), min, max, overflow);
}
function clampEntity(entityName, num, min, max, overflow, choices) {
const clamped = clampNumber(num, min, max);
if (overflow && num !== clamped) {
throw new RangeError(numberOutOfRange(entityName, num, min, max, choices));
}
return clamped;
}
function isObjectLike(arg) {
return null !== arg && /object|function/.test(typeof arg);
}
function memoize(generator, MapClass = Map) {
const map = new MapClass;
return (key, ...otherArgs) => {
if (map.has(key)) {
return map.get(key);
}
const val = generator(key, ...otherArgs);
return map.set(key, val), val;
};
}
function createNameDescriptors(name) {
return createPropDescriptors({
name: name
}, 1);
}
function createPropDescriptors(propVals, readonly) {
return mapProps((value => ({
value: value,
configurable: 1,
writable: !readonly
})), propVals);
}
function createGetterDescriptors(getters) {
return mapProps((getter => ({
get: getter,
configurable: 1
})), getters);
}
function createStringTagDescriptors(value) {
return {
[Symbol.toStringTag]: {
value: value,
configurable: 1
}
};
}
function zipProps(propNamesRev, args) {
const res = {};
let i = propNamesRev.length;
for (const arg of args) {
res[propNamesRev[--i]] = arg;
}
return res;
}
function mapProps(transformer, props, extraArg) {
const res = {};
for (const propName in props) {
res[propName] = transformer(props[propName], propName, extraArg);
}
return res;
}
function mapPropNames(generator, propNames, extraArg) {
const props = {};
for (let i = 0; i < propNames.length; i++) {
const propName = propNames[i];
props[propName] = generator(propName, i, extraArg);
}
return props;
}
function remapProps(oldNames, newNames, oldProps) {
const newProps = {};
for (let i = 0; i < oldNames.length; i++) {
newProps[newNames[i]] = oldProps[oldNames[i]];
}
return newProps;
}
function pluckProps(propNames, props) {
const res = Object.create(null);
for (const propName of propNames) {
res[propName] = props[propName];
}
return res;
}
function hasAnyPropsByName(props, names) {
for (const name of names) {
if (name in props) {
return 1;
}
}
return 0;
}
function allPropsEqual(propNames, props0, props1) {
for (const propName of propNames) {
if (props0[propName] !== props1[propName]) {
return 0;
}
}
return 1;
}
function zeroOutProps(propNames, clearUntilI, props) {
const copy = {
...props
};
for (let i = 0; i < clearUntilI; i++) {
copy[propNames[i]] = 0;
}
return copy;
}
function bindArgs(f, ...boundArgs) {
return (...dynamicArgs) => f(...boundArgs, ...dynamicArgs);
}
function capitalize(s) {
return s[0].toUpperCase() + s.substring(1);
}
function sortStrings(strs) {
return strs.slice().sort();
}
function padNumber(digits, num) {
return String(num).padStart(digits, "0");
}
function compareNumbers(a, b) {
return Math.sign(a - b);
}
function clampNumber(num, min, max) {
return Math.min(Math.max(num, min), max);
}
function divModFloor(num, divisor) {
return [ Math.floor(num / divisor), modFloor(num, divisor) ];
}
function modFloor(num, divisor) {
return (num % divisor + divisor) % divisor;
}
function divModTrunc(num, divisor) {
return [ divTrunc(num, divisor), modTrunc(num, divisor) ];
}
function divTrunc(num, divisor) {
return Math.trunc(num / divisor) || 0;
}
function modTrunc(num, divisor) {
return num % divisor || 0;
}
function hasHalf(num) {
return .5 === Math.abs(num % 1);
}
function givenFieldsToBigNano(fields, largestUnit, fieldNames) {
let timeNano = 0, days = 0;
for (let unit = 0; unit <= largestUnit; unit++) {
const fieldVal = fields[fieldNames[unit]], unitNano = unitNanoMap[unit], unitInDay = nanoInUtcDay / unitNano, [unitDays, leftoverUnits] = divModTrunc(fieldVal, unitInDay);
timeNano += leftoverUnits * unitNano, days += unitDays;
}
const [timeDays, leftoverNano] = divModTrunc(timeNano, nanoInUtcDay);
return [ days + timeDays, leftoverNano ];
}
function nanoToGivenFields(nano, largestUnit, fieldNames) {
const fields = {};
for (let unit = largestUnit; unit >= 0; unit--) {
const divisor = unitNanoMap[unit];
fields[fieldNames[unit]] = divTrunc(nano, divisor), nano = modTrunc(nano, divisor);
}
return fields;
}
function createBigNano(days, timeNano) {
let [extraDays, newTimeNano] = divModTrunc(timeNano, nanoInUtcDay), newDays = days + extraDays;
const newDaysSign = Math.sign(newDays);
return newDaysSign && newDaysSign === -Math.sign(newTimeNano) && (newDays -= newDaysSign,
newTimeNano += newDaysSign * nanoInUtcDay), [ newDays, newTimeNano ];
}
function addBigNanos(a, b, sign = 1) {
return createBigNano(a[0] + b[0] * sign, a[1] + b[1] * sign);
}
function moveBigNano(a, b) {
return createBigNano(a[0], a[1] + b);
}
function diffBigNanos(a, b) {
return addBigNanos(b, a, -1);
}
function compareBigNanos(a, b) {
return compareNumbers(a[0], b[0]) || compareNumbers(a[1], b[1]);
}
function bigNanoOutside(subject, rangeStart, rangeEndExcl) {
return -1 === compareBigNanos(subject, rangeStart) || 1 === compareBigNanos(subject, rangeEndExcl);
}
function bigIntToBigNano(num, multiplierNano = 1) {
const wholeInDay = BigInt(nanoInUtcDay / multiplierNano);
return [ Number(num / wholeInDay), Number(num % wholeInDay) * multiplierNano ];
}
function numberToBigNano(num, multiplierNano = 1) {
const wholeInDay = nanoInUtcDay / multiplierNano, [days, remainder] = divModTrunc(num, wholeInDay);
return [ days, remainder * multiplierNano ];
}
function bigNanoToNumber(bigNano, divisorNano = 1, exact) {
const [days, timeNano] = bigNano, [whole, remainderNano] = divModTrunc(timeNano, divisorNano);
return days * (nanoInUtcDay / divisorNano) + (whole + (exact ? remainderNano / divisorNano : 0));
}
function divModBigNano(bigNano, divisorNano, divModFunc = divModFloor) {
const [days, timeNano] = bigNano, [whole, remainderNano] = divModFunc(timeNano, divisorNano);
return [ days * (nanoInUtcDay / divisorNano) + whole, remainderNano ];
}
function requireIntegerOrUndefined(input) {
if (void 0 !== input) {
return requireInteger(input);
}
}
function requirePositiveInteger(arg) {
return requireNumberIsPositive(requireInteger(arg));
}
function requireInteger(arg) {
return requireNumberIsInteger(requireNumber(arg));
}
function requirePropDefined(optionName, optionVal) {
if (null == optionVal) {
throw new RangeError(missingField(optionName));
}
return optionVal;
}
function requireObjectLike(arg) {
if (!isObjectLike(arg)) {
throw new TypeError(invalidObject);
}
return arg;
}
function requireType(typeName, arg, entityName = typeName) {
if (typeof arg !== typeName) {
throw new TypeError(invalidEntity(entityName, arg));
}
return arg;
}
function requireNumberIsInteger(num, entityName = "number") {
if (!Number.isInteger(num)) {
throw new RangeError(expectedInteger(entityName, num));
}
return num || 0;
}
function requireNumberIsPositive(num, entityName = "number") {
if (num <= 0) {
throw new RangeError(expectedPositive(entityName, num));
}
return num;
}
function toString(arg) {
if ("symbol" == typeof arg) {
throw new TypeError(forbiddenSymbolToString);
}
return String(arg);
}
function toStringViaPrimitive(arg, entityName) {
return isObjectLike(arg) ? String(arg) : requireString(arg, entityName);
}
function toBigInt(bi) {
if ("string" == typeof bi) {
return BigInt(bi);
}
if ("bigint" != typeof bi) {
throw new TypeError(invalidBigInt(bi));
}
return bi;
}
function toNumber(arg, entityName = "number") {
if ("bigint" == typeof arg) {
throw new TypeError(forbiddenBigIntToNumber(entityName));
}
if (arg = Number(arg), !Number.isFinite(arg)) {
throw new RangeError(expectedFinite(entityName, arg));
}
return arg;
}
function toInteger(arg, entityName) {
return Math.trunc(toNumber(arg, entityName)) || 0;
}
function toStrictInteger(arg, entityName) {
return requireNumberIsInteger(toNumber(arg, entityName), entityName);
}
function toPositiveInteger(arg, entityName) {
return requireNumberIsPositive(toInteger(arg, entityName), entityName);
}
function checkIsoYearMonthInBounds(isoFields) {
return clampProp(isoFields, "isoYear", isoYearMin, isoYearMax, 1), isoFields.isoYear === isoYearMin ? clampProp(isoFields, "isoMonth", 4, 12, 1) : isoFields.isoYear === isoYearMax && clampProp(isoFields, "isoMonth", 1, 9, 1),
isoFields;
}
function checkIsoDateInBounds(isoFields) {
return checkIsoDateTimeInBounds({
...isoFields,
...isoTimeFieldDefaults,
isoHour: 12
}), isoFields;
}
function checkIsoDateTimeInBounds(isoFields) {
const isoYear = clampProp(isoFields, "isoYear", isoYearMin, isoYearMax, 1), nudge = isoYear === isoYearMin ? 1 : isoYear === isoYearMax ? -1 : 0;
return nudge && checkEpochNanoInBounds(isoToEpochNano({
...isoFields,
isoDay: isoFields.isoDay + nudge,
isoNanosecond: isoFields.isoNanosecond - nudge
})), isoFields;
}
function checkEpochNanoInBounds(epochNano) {
if (!epochNano || bigNanoOutside(epochNano, epochNanoMin, epochNanoMax)) {
throw new RangeError(outOfBoundsDate);
}
return epochNano;
}
function isoTimeFieldsToNano(isoTimeFields) {
return givenFieldsToBigNano(isoTimeFields, 5, isoTimeFieldNamesAsc)[1];
}
function nanoToIsoTimeAndDay(nano) {
const [dayDelta, timeNano] = divModFloor(nano, nanoInUtcDay);
return [ nanoToGivenFields(timeNano, 5, isoTimeFieldNamesAsc), dayDelta ];
}
function epochNanoToSecMod(epochNano) {
return divModBigNano(epochNano, nanoInSec);
}
function isoToEpochMilli(isoDateTimeFields) {
return isoArgsToEpochMilli(isoDateTimeFields.isoYear, isoDateTimeFields.isoMonth, isoDateTimeFields.isoDay, isoDateTimeFields.isoHour, isoDateTimeFields.isoMinute, isoDateTimeFields.isoSecond, isoDateTimeFields.isoMillisecond);
}
function isoToEpochNano(isoFields) {
const epochMilli = isoToEpochMilli(isoFields);
if (void 0 !== epochMilli) {
const [days, milliRemainder] = divModTrunc(epochMilli, milliInDay);
return [ days, milliRemainder * nanoInMilli + (isoFields.isoMicrosecond || 0) * nanoInMicro + (isoFields.isoNanosecond || 0) ];
}
}
function isoToEpochNanoWithOffset(isoFields, offsetNano) {
const [newIsoTimeFields, dayDelta] = nanoToIsoTimeAndDay(isoTimeFieldsToNano(isoFields) - offsetNano);
return checkEpochNanoInBounds(isoToEpochNano({
...isoFields,
isoDay: isoFields.isoDay + dayDelta,
...newIsoTimeFields
}));
}
function isoArgsToEpochSec(...args) {
return isoArgsToEpochMilli(...args) / milliInSec;
}
function isoArgsToEpochMilli(...args) {
const [legacyDate, daysNudged] = isoToLegacyDate(...args), epochMilli = legacyDate.valueOf();
if (!isNaN(epochMilli)) {
return epochMilli - daysNudged * milliInDay;
}
}
function isoToLegacyDate(isoYear, isoMonth = 1, isoDay = 1, isoHour = 0, isoMinute = 0, isoSec = 0, isoMilli = 0) {
const daysNudged = isoYear === isoYearMin ? 1 : isoYear === isoYearMax ? -1 : 0, legacyDate = new Date;
return legacyDate.setUTCHours(isoHour, isoMinute, isoSec, isoMilli), legacyDate.setUTCFullYear(isoYear, isoMonth - 1, isoDay + daysNudged),
[ legacyDate, daysNudged ];
}
function epochNanoToIso(epochNano, offsetNano) {
let [days, timeNano] = moveBigNano(epochNano, offsetNano);
timeNano < 0 && (timeNano += nanoInUtcDay, days -= 1);
const [timeMilli, nanoRemainder] = divModFloor(timeNano, nanoInMilli), [isoMicrosecond, isoNanosecond] = divModFloor(nanoRemainder, nanoInMicro);
return epochMilliToIso(days * milliInDay + timeMilli, isoMicrosecond, isoNanosecond);
}
function epochMilliToIso(epochMilli, isoMicrosecond = 0, isoNanosecond = 0) {
const daysOver = Math.ceil(Math.max(0, Math.abs(epochMilli) - maxMilli) / milliInDay) * Math.sign(epochMilli), legacyDate = new Date(epochMilli - daysOver * milliInDay);
return zipProps(isoDateTimeFieldNamesAsc, [ legacyDate.getUTCFullYear(), legacyDate.getUTCMonth() + 1, legacyDate.getUTCDate() + daysOver, legacyDate.getUTCHours(), legacyDate.getUTCMinutes(), legacyDate.getUTCSeconds(), legacyDate.getUTCMilliseconds(), isoMicrosecond, isoNanosecond ]);
}
function hashIntlFormatParts(intlFormat, epochMilli) {
if (epochMilli < -maxMilli) {
throw new RangeError(outOfBoundsDate);
}
const parts = intlFormat.formatToParts(epochMilli), hash = {};
for (const part of parts) {
hash[part.type] = part.value;
}
return hash;
}
function computeIsoDateParts(isoFields) {
return [ isoFields.isoYear, isoFields.isoMonth, isoFields.isoDay ];
}
function computeIsoMonthCodeParts(_isoYear, isoMonth) {
return [ isoMonth, 0 ];
}
function computeIsoMonthsInYear() {
return isoMonthsInYear;
}
function computeIsoDaysInMonth(isoYear, isoMonth) {
switch (isoMonth) {
case 2:
return computeIsoInLeapYear(isoYear) ? 29 : 28;
case 4:
case 6:
case 9:
case 11:
return 30;
}
return 31;
}
function computeIsoDaysInYear(isoYear) {
return computeIsoInLeapYear(isoYear) ? 366 : 365;
}
function computeIsoInLeapYear(isoYear) {
return isoYear % 4 == 0 && (isoYear % 100 != 0 || isoYear % 400 == 0);
}
function computeIsoDayOfWeek(isoDateFields) {
const [legacyDate, daysNudged] = isoToLegacyDate(isoDateFields.isoYear, isoDateFields.isoMonth, isoDateFields.isoDay);
return modFloor(legacyDate.getUTCDay() - daysNudged, 7) || 7;
}
function computeIsoEraParts(isoFields) {
return this.id === gregoryCalendarId ? (({isoYear: isoYear}) => isoYear < 1 ? [ "gregory-inverse", 1 - isoYear ] : [ "gregory", isoYear ])(isoFields) : "japanese" === this.id ? queryJapaneseEraParts(isoFields) : [];
}
function checkIsoDateTimeFields(isoDateTimeFields) {
return checkIsoDateFields(isoDateTimeFields), constrainIsoTimeFields(isoDateTimeFields, 1),
isoDateTimeFields;
}
function checkIsoDateFields(isoInternals) {
return constrainIsoDateFields(isoInternals, 1), isoInternals;
}
function isIsoDateFieldsValid(isoFields) {
return allPropsEqual(isoDateFieldNamesAsc, isoFields, constrainIsoDateFields(isoFields));
}
function constrainIsoDateFields(isoFields, overflow) {
const {isoYear: isoYear} = isoFields, isoMonth = clampProp(isoFields, "isoMonth", 1, computeIsoMonthsInYear(), overflow);
return {
isoYear: isoYear,
isoMonth: isoMonth,
isoDay: clampProp(isoFields, "isoDay", 1, computeIsoDaysInMonth(isoYear, isoMonth), overflow)
};
}
function constrainIsoTimeFields(isoTimeFields, overflow) {
return zipProps(isoTimeFieldNamesAsc, [ clampProp(isoTimeFields, "isoHour", 0, 23, overflow), clampProp(isoTimeFields, "isoMinute", 0, 59, overflow), clampProp(isoTimeFields, "isoSecond", 0, 59, overflow), clampProp(isoTimeFields, "isoMillisecond", 0, 999, overflow), clampProp(isoTimeFields, "isoMicrosecond", 0, 999, overflow), clampProp(isoTimeFields, "isoNanosecond", 0, 999, overflow) ]);
}
function createIntlFieldCache(epochMilliToIntlFields) {
return memoize((isoDateFields => {
const epochMilli = isoToEpochMilli(isoDateFields);
return epochMilliToIntlFields(epochMilli);
}), WeakMap);
}
function createIntlYearDataCache(epochMilliToIntlFields) {
const yearCorrection = epochMilliToIntlFields(0).year - isoEpochOriginYear;
return memoize((year => {
let intlFields, epochMilli = isoArgsToEpochMilli(year - yearCorrection), iterations = 0;
const millisReversed = [], monthStringsReversed = [];
do {
epochMilli += 400 * milliInDay;
} while ((intlFields = epochMilliToIntlFields(epochMilli)).year <= year);
do {
if (epochMilli += (1 - intlFields.day) * milliInDay, intlFields.year === year && (millisReversed.push(epochMilli),
monthStringsReversed.push(intlFields.monthString)), epochMilli -= milliInDay, ++iterations > 100 || epochMilli < -maxMilli) {
throw new RangeError(invalidProtocolResults);
}
} while ((intlFields = epochMilliToIntlFields(epochMilli)).year >= year);
return {
monthEpochMillis: millisReversed.reverse(),
monthStringToIndex: mapPropNamesToIndex(monthStringsReversed.reverse())
};
}));
}
function parseIntlYear(intlParts, calendarIdBase) {
let era, eraYear, year = parseIntlPartsYear(intlParts);
if (intlParts.era) {
const eraOrigins = eraOriginsByCalendarId[calendarIdBase], eraRemaps = eraRemapsByCalendarId[calendarIdBase] || {};
void 0 !== eraOrigins && (era = "islamic" === calendarIdBase ? "ah" : intlParts.era.normalize("NFD").toLowerCase().replace(/[^a-z0-9]/g, ""),
"bc" === era || "b" === era ? era = "bce" : "ad" === era || "a" === era ? era = "ce" : "beforeroc" === era && (era = "broc"),
era = eraRemaps[era] || era, eraYear = year, year = eraYearToYear(eraYear, eraOrigins[era] || 0));
}
return {
era: era,
eraYear: eraYear,
year: year
};
}
function parseIntlPartsYear(intlParts) {
return parseInt(intlParts.relatedYear || intlParts.year);
}
function computeIntlDateParts(isoFields) {
const {year: year, monthString: monthString, day: day} = this.queryFields(isoFields), {monthStringToIndex: monthStringToIndex} = this.queryYearData(year);
return [ year, monthStringToIndex[monthString] + 1, day ];
}
function computeIntlEpochMilli(year, month = 1, day = 1) {
return this.queryYearData(year).monthEpochMillis[month - 1] + (day - 1) * milliInDay;
}
function computeIntlMonthCodeParts(year, month) {
const leapMonth = computeIntlLeapMonth.call(this, year);
return [ monthToMonthCodeNumber(month, leapMonth), leapMonth === month ];
}
function computeIntlLeapMonth(year) {
const currentMonthStrings = queryMonthStrings(this, year), prevMonthStrings = queryMonthStrings(this, year - 1), currentLength = currentMonthStrings.length;
if (currentLength > prevMonthStrings.length) {
const leapMonthMeta = getCalendarLeapMonthMeta(this);
if (leapMonthMeta < 0) {
return -leapMonthMeta;
}
for (let i = 0; i < currentLength; i++) {
if (currentMonthStrings[i] !== prevMonthStrings[i]) {
return i + 1;
}
}
}
}
function computeIntlDaysInYear(year) {
return diffEpochMilliByDay(computeIntlEpochMilli.call(this, year), computeIntlEpochMilli.call(this, year + 1));
}
function computeIntlDaysInMonth(year, month) {
const {monthEpochMillis: monthEpochMillis} = this.queryYearData(year);
let nextMonth = month + 1, nextMonthEpochMilli = monthEpochMillis;
return nextMonth > monthEpochMillis.length && (nextMonth = 1, nextMonthEpochMilli = this.queryYearData(year + 1).monthEpochMillis),
diffEpochMilliByDay(monthEpochMillis[month - 1], nextMonthEpochMilli[nextMonth - 1]);
}
function computeIntlMonthsInYear(year) {
return this.queryYearData(year).monthEpochMillis.length;
}
function computeIntlEraParts(isoFields) {
const intlFields = this.queryFields(isoFields);
return [ intlFields.era, intlFields.eraYear ];
}
function queryMonthStrings(intlCalendar, year) {
return Object.keys(intlCalendar.queryYearData(year).monthStringToIndex);
}
function refineCalendarId(id) {
return resolveCalendarId(requireString(id));
}
function resolveCalendarId(id) {
if ((id = id.toLowerCase()) !== isoCalendarId && id !== gregoryCalendarId) {
const canonId = queryCalendarIntlFormat(id).resolvedOptions().calendar;
if (computeCalendarIdBase(id) !== computeCalendarIdBase(canonId)) {
throw new RangeError(invalidCalendar(id));
}
return canonId;
}
return id;
}
function computeCalendarIdBase(id) {
return "islamicc" === id && (id = "islamic"), id.split("-")[0];
}
function computeNativeWeekOfYear(isoFields) {
return this.weekParts(isoFields)[0];
}
function computeNativeYearOfWeek(isoFields) {
return this.weekParts(isoFields)[1];
}
function computeNativeDayOfYear(isoFields) {
const [year] = this.dateParts(isoFields);
return diffEpochMilliByDay(this.epochMilli(year), isoToEpochMilli(isoFields)) + 1;
}
function parseMonthCode(monthCode) {
const m = monthCodeRegExp.exec(monthCode);
if (!m) {
throw new RangeError(invalidMonthCode(monthCode));
}
return [ parseInt(m[1]), Boolean(m[2]) ];
}
function formatMonthCode(monthCodeNumber, isLeapMonth) {
return "M" + padNumber2(monthCodeNumber) + (isLeapMonth ? "L" : "");
}
function monthCodeNumberToMonth(monthCodeNumber, isLeapMonth, leapMonth) {
return monthCodeNumber + (isLeapMonth || leapMonth && monthCodeNumber >= leapMonth ? 1 : 0);
}
function monthToMonthCodeNumber(month, leapMonth) {
return month - (leapMonth && month >= leapMonth ? 1 : 0);
}
function eraYearToYear(eraYear, eraOrigin) {
return (eraOrigin + eraYear) * (Math.sign(eraOrigin) || 1) || 0;
}
function getCalendarEraOrigins(native) {
return eraOriginsByCalendarId[getCalendarIdBase(native)];
}
function getCalendarLeapMonthMeta(native) {
return leapMonthMetas[getCalendarIdBase(native)];
}
function getCalendarIdBase(native) {
return computeCalendarIdBase(native.id || isoCalendarId);
}
function refineOverflowOptions(options) {
return void 0 === options ? 0 : refineOverflow(requireObjectLike(options));
}
function refineZonedFieldOptions(options, defaultOffsetDisambig = 0) {
options = normalizeOptions(options);
const epochDisambig = refineEpochDisambig(options), offsetDisambig = refineOffsetDisambig(options, defaultOffsetDisambig);
return [ refineOverflow(options), offsetDisambig, epochDisambig ];
}
function refineDiffOptions(roundingModeInvert, options, defaultLargestUnit, maxUnit = 9, minUnit = 0, defaultRoundingMode = 4) {
options = normalizeOptions(options);
let largestUnit = refineLargestUnit(options, maxUnit, minUnit), roundingInc = parseRoundingIncInteger(options), roundingMode = refineRoundingMode(options, defaultRoundingMode);
const smallestUnit = refineSmallestUnit(options, maxUnit, minUnit, 1);
return null == largestUnit ? largestUnit = Math.max(defaultLargestUnit, smallestUnit) : checkLargestSmallestUnit(largestUnit, smallestUnit),
roundingInc = refineRoundingInc(roundingInc, smallestUnit, 1), roundingModeInvert && (roundingMode = (roundingMode => roundingMode < 4 ? (roundingMode + 2) % 4 : roundingMode)(roundingMode)),
[ largestUnit, smallestUnit, roundingInc, roundingMode ];
}
function refineRoundingOptions(options, maxUnit = 6, solarMode) {
let roundingInc = parseRoundingIncInteger(options = normalizeOptionsOrString(options, smallestUnitStr));
const roundingMode = refineRoundingMode(options, 7);
let smallestUnit = refineSmallestUnit(options, maxUnit);
return smallestUnit = requirePropDefined(smallestUnitStr, smallestUnit), roundingInc = refineRoundingInc(roundingInc, smallestUnit, void 0, solarMode),
[ smallestUnit, roundingInc, roundingMode ];
}
function refineDateDisplayOptions(options) {
return refineCalendarDisplay(normalizeOptions(options));
}
function refineTimeDisplayOptions(options, maxSmallestUnit) {
return refineTimeDisplayTuple(normalizeOptions(options), maxSmallestUnit);
}
function refineTimeDisplayTuple(options, maxSmallestUnit = 4) {
const subsecDigits = refineSubsecDigits(options);
return [ refineRoundingMode(options, 4), ...refineSmallestUnitAndSubsecDigits(refineSmallestUnit(options, maxSmallestUnit), subsecDigits) ];
}
function refineSmallestUnitAndSubsecDigits(smallestUnit, subsecDigits) {
return null != smallestUnit ? [ unitNanoMap[smallestUnit], smallestUnit < 4 ? 9 - 3 * smallestUnit : -1 ] : [ void 0 === subsecDigits ? 1 : 10 ** (9 - subsecDigits), subsecDigits ];
}
function parseRoundingIncInteger(options) {
const roundingInc = options[roundingIncName];
return void 0 === roundingInc ? 1 : toInteger(roundingInc, roundingIncName);
}
function refineRoundingInc(roundingInc, smallestUnit, allowManyLargeUnits, solarMode) {
const upUnitNano = solarMode ? nanoInUtcDay : unitNanoMap[smallestUnit + 1];
if (upUnitNano) {
const unitNano = unitNanoMap[smallestUnit];
if (upUnitNano % ((roundingInc = clampEntity(roundingIncName, roundingInc, 1, upUnitNano / unitNano - (solarMode ? 0 : 1), 1)) * unitNano)) {
throw new RangeError(invalidEntity(roundingIncName, roundingInc));
}
} else {
roundingInc = clampEntity(roundingIncName, roundingInc, 1, allowManyLargeUnits ? 10 ** 9 : 1, 1);
}
return roundingInc;
}
function refineSubsecDigits(options) {
let subsecDigits = options[subsecDigitsName];
if (void 0 !== subsecDigits) {
if ("number" != typeof subsecDigits) {
if ("auto" === toString(subsecDigits)) {
return;
}
throw new RangeError(invalidEntity(subsecDigitsName, subsecDigits));
}
subsecDigits = clampEntity(subsecDigitsName, Math.floor(subsecDigits), 0, 9, 1);
}
return subsecDigits;
}
function normalizeOptions(options) {
return void 0 === options ? {} : requireObjectLike(options);
}
function normalizeOptionsOrString(options, optionName) {
return "string" == typeof options ? {
[optionName]: options
} : requireObjectLike(options);
}
function fabricateOverflowOptions(overflow) {
return {
overflow: overflowMapNames[overflow]
};
}
function refineUnitOption(optionName, options, maxUnit = 9, minUnit = 0, ensureDefined) {
let unitStr = options[optionName];
if (void 0 === unitStr) {
return ensureDefined ? minUnit : void 0;
}
if (unitStr = toString(unitStr), "auto" === unitStr) {
return ensureDefined ? minUnit : null;
}
let unit = unitNameMap[unitStr];
if (void 0 === unit && (unit = durationFieldIndexes[unitStr]), void 0 === unit) {
throw new RangeError(invalidChoice(optionName, unitStr, unitNameMap));
}
return clampEntity(optionName, unit, minUnit, maxUnit, 1, unitNamesAsc), unit;
}
function refineChoiceOption(optionName, enumNameMap, options, defaultChoice = 0) {
const enumArg = options[optionName];
if (void 0 === enumArg) {
return defaultChoice;
}
const enumStr = toString(enumArg), enumNum = enumNameMap[enumStr];
if (void 0 === enumNum) {
throw new RangeError(invalidChoice(optionName, enumStr, enumNameMap));
}
return enumNum;
}
function checkLargestSmallestUnit(largestUnit, smallestUnit) {
if (smallestUnit > largestUnit) {
throw new RangeError(flippedSmallestLargestUnit);
}
}
function createInstantSlots(epochNano) {
return {
branding: InstantBranding,
epochNanoseconds: epochNano
};
}
function createZonedDateTimeSlots(epochNano, timeZoneId, calendarId) {
return {
branding: ZonedDateTimeBranding,
calendar: calendarId,
timeZone: timeZoneId,
epochNanoseconds: epochNano
};
}
function createPlainDateTimeSlots(isoFields, calendar = isoFields.calendar) {
return {
branding: PlainDateTimeBranding,
calendar: calendar,
...pluckProps(isoDateTimeFieldNamesAlpha, isoFields)
};
}
function createPlainDateSlots(isoFields, calendar = isoFields.calendar) {
return {
branding: PlainDateBranding,
calendar: calendar,
...pluckProps(isoDateFieldNamesAlpha, isoFields)
};
}
function createPlainYearMonthSlots(isoFields, calendar = isoFields.calendar) {
return {
branding: PlainYearMonthBranding,
calendar: calendar,
...pluckProps(isoDateFieldNamesAlpha, isoFields)
};
}
function createPlainMonthDaySlots(isoFields, calendar = isoFields.calendar) {
return {
branding: PlainMonthDayBranding,
calendar: calendar,
...pluckProps(isoDateFieldNamesAlpha, isoFields)
};
}
function createPlainTimeSlots(isoFields) {
return {
branding: PlainTimeBranding,
...pluckProps(isoTimeFieldNamesAlpha, isoFields)
};
}
function createDurationSlots(durationFields) {
return {
branding: DurationBranding,
sign: computeDurationSign(durationFields),
...pluckProps(durationFieldNamesAlpha, durationFields)
};
}
function getEpochMilli(slots) {
return divModBigNano(slots.epochNanoseconds, nanoInMilli)[0];
}
function extractEpochNano(slots) {
return slots.epochNanoseconds;
}
function totalDayTimeDuration(durationFields, totalUnit) {
return bigNanoToNumber(durationFieldsToBigNano(durationFields), unitNanoMap[totalUnit], 1);
}
function clampRelativeDuration(calendarOps, durationFields, clampUnit, clampDistance, marker, markerToEpochNano, moveMarker) {
const unitName = durationFieldNamesAsc[clampUnit], durationPlusDistance = {
...durationFields,
[unitName]: durationFields[unitName] + clampDistance
}, marker0 = moveMarker(calendarOps, marker, durationFields), marker1 = moveMarker(calendarOps, marker, durationPlusDistance);
return [ markerToEpochNano(marker0), markerToEpochNano(marker1) ];
}
function computeEpochNanoFrac(epochNanoProgress, epochNano0, epochNano1) {
const denom = bigNanoToNumber(diffBigNanos(epochNano0, epochNano1));
if (!denom) {
throw new RangeError(invalidProtocolResults);
}
return bigNanoToNumber(diffBigNanos(epochNano0, epochNanoProgress)) / denom;
}
function roundDateTime(isoFields, smallestUnit, roundingInc, roundingMode) {
return roundDateTimeToNano(isoFields, computeNanoInc(smallestUnit, roundingInc), roundingMode);
}
function roundDateTimeToNano(isoFields, nanoInc, roundingMode) {
const [roundedIsoFields, dayDelta] = roundTimeToNano(isoFields, nanoInc, roundingMode);
return checkIsoDateTimeInBounds({
...moveByDays(isoFields, dayDelta),
...roundedIsoFields
});
}
function roundTimeToNano(isoFields, nanoInc, roundingMode) {
return nanoToIsoTimeAndDay(roundByInc(isoTimeFieldsToNano(isoFields), nanoInc, roundingMode));
}
function roundToMinute(offsetNano) {
return roundByInc(offsetNano, nanoInMinute, 7);
}
function computeNanoInc(smallestUnit, roundingInc) {
return unitNanoMap[smallestUnit] * roundingInc;
}
function computeDayInterval(isoFields) {
const isoFields0 = computeDayFloor(isoFields);
return [ isoFields0, moveByDays(isoFields0, 1) ];
}
function computeDayFloor(isoFields) {
return clearIsoFields(6, isoFields);
}
function roundDayTimeDurationByInc(durationFields, nanoInc, roundingMode) {
const maxUnit = Math.min(getMaxDurationUnit(durationFields), 6);
return nanoToDurationDayTimeFields(roundBigNanoByInc(durationFieldsToBigNano(durationFields, maxUnit), nanoInc, roundingMode), maxUnit);
}
function roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, marker, markerToEpochNano, moveMarker) {
if (0 === smallestUnit && 1 === roundingInc) {
return durationFields;
}
const nudgeFunc = isUniformUnit(smallestUnit, marker) ? isZonedEpochSlots(marker) && smallestUnit < 6 && largestUnit >= 6 ? nudgeZonedTimeDuration : nudgeDayTimeDuration : nudgeRelativeDuration;
let [roundedDurationFields, roundedEpochNano, grewBigUnit] = nudgeFunc(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, marker, markerToEpochNano, moveMarker);
return grewBigUnit && 7 !== smallestUnit && (roundedDurationFields = ((durationFields, endEpochNano, largestUnit, smallestUnit, calendarOps, marker, markerToEpochNano, moveMarker) => {
const sign = computeDurationSign(durationFields);
for (let currentUnit = smallestUnit + 1; currentUnit <= largestUnit; currentUnit++) {
if (7 === currentUnit && 7 !== largestUnit) {
continue;
}
const baseDurationFields = clearDurationFields(currentUnit, durationFields);
baseDurationFields[durationFieldNamesAsc[currentUnit]] += sign;
const beyondThresholdNano = bigNanoToNumber(diffBigNanos(markerToEpochNano(moveMarker(calendarOps, marker, baseDurationFields)), endEpochNano));
if (beyondThresholdNano && Math.sign(beyondThresholdNano) !== sign) {
break;
}
durationFields = baseDurationFields;
}
return durationFields;
})(roundedDurationFields, roundedEpochNano, largestUnit, Math.max(6, smallestUnit), calendarOps, marker, markerToEpochNano, moveMarker)),
roundedDurationFields;
}
function roundBigNano(bigNano, smallestUnit, roundingInc, roundingMode, useDayOrigin) {
if (6 === smallestUnit) {
const daysExact = (bigNano => bigNano[0] + bigNano[1] / nanoInUtcDay)(bigNano);
return [ roundByInc(daysExact, roundingInc, roundingMode), 0 ];
}
return roundBigNanoByInc(bigNano, computeNanoInc(smallestUnit, roundingInc), roundingMode, useDayOrigin);
}
function roundBigNanoByInc(bigNano, nanoInc, roundingMode, useDayOrigin) {
let [days, timeNano] = bigNano;
useDayOrigin && timeNano < 0 && (timeNano += nanoInUtcDay, days -= 1);
const [dayDelta, roundedTimeNano] = divModFloor(roundByInc(timeNano, nanoInc, roundingMode), nanoInUtcDay);
return createBigNano(days + dayDelta, roundedTimeNano);
}
function roundByInc(num, inc, roundingMode) {
return roundWithMode(num / inc, roundingMode) * inc;
}
function roundWithMode(num, roundingMode) {
return roundingModeFuncs[roundingMode](num);
}
function nudgeDayTimeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) {
const sign = computeDurationSign(durationFields), bigNano = durationFieldsToBigNano(durationFields), roundedBigNano = roundBigNano(bigNano, smallestUnit, roundingInc, roundingMode), nanoDiff = diffBigNanos(bigNano, roundedBigNano), expandedBigUnit = Math.sign(roundedBigNano[0] - bigNano[0]) === sign, roundedDayTimeFields = nanoToDurationDayTimeFields(roundedBigNano, Math.min(largestUnit, 6));
return [ {
...durationFields,
...roundedDayTimeFields
}, addBigNanos(endEpochNano, nanoDiff), expandedBigUnit ];
}
function nudgeZonedTimeDuration(durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, marker, markerToEpochNano, moveMarker) {
const sign = computeDurationSign(durationFields) || 1, timeNano = bigNanoToNumber(durationFieldsToBigNano(durationFields, 5)), nanoInc = computeNanoInc(smallestUnit, roundingInc);
let roundedTimeNano = roundByInc(timeNano, nanoInc, roundingMode);
const [dayEpochNano0, dayEpochNano1] = clampRelativeDuration(calendarOps, {
...durationFields,
...durationTimeFieldDefaults
}, 6, sign, marker, markerToEpochNano, moveMarker), beyondDayNano = roundedTimeNano - bigNanoToNumber(diffBigNanos(dayEpochNano0, dayEpochNano1));
let dayDelta = 0;
beyondDayNano && Math.sign(beyondDayNano) !== sign ? endEpochNano = moveBigNano(dayEpochNano0, roundedTimeNano) : (dayDelta += sign,
roundedTimeNano = roundByInc(beyondDayNano, nanoInc, roundingMode), endEpochNano = moveBigNano(dayEpochNano1, roundedTimeNano));
const durationTimeFields = nanoToDurationTimeFields(roundedTimeNano);
return [ {
...durationFields,
...durationTimeFields,
days: durationFields.days + dayDelta
}, endEpochNano, Boolean(dayDelta) ];
}
function nudgeRelativeDuration(durationFields, endEpochNano, _largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, marker, markerToEpochNano, moveMarker) {
const sign = computeDurationSign(durationFields), smallestUnitFieldName = durationFieldNamesAsc[smallestUnit], baseDurationFields = clearDurationFields(smallestUnit, durationFields);
7 === smallestUnit && (durationFields = {
...durationFields,
weeks: durationFields.weeks + Math.trunc(durationFields.days / 7)
});
const truncedVal = divTrunc(durationFields[smallestUnitFieldName], roundingInc) * roundingInc;
baseDurationFields[smallestUnitFieldName] = truncedVal;
const [epochNano0, epochNano1] = clampRelativeDuration(calendarOps, baseDurationFields, smallestUnit, roundingInc * sign, marker, markerToEpochNano, moveMarker), exactVal = truncedVal + computeEpochNanoFrac(endEpochNano, epochNano0, epochNano1) * sign * roundingInc, roundedVal = roundByInc(exactVal, roundingInc, roundingMode), expanded = Math.sign(roundedVal - exactVal) === sign;
return baseDurationFields[smallestUnitFieldName] = roundedVal, [ baseDurationFields, expanded ? epochNano1 : epochNano0, expanded ];
}
function formatInstantIso(refineTimeZoneString, getTimeZoneOps, instantSlots, options) {
const [timeZoneArg, roundingMode, nanoInc, subsecDigits] = (options => {
const timeDisplayTuple = refineTimeDisplayTuple(options = normalizeOptions(options));
return [ options.timeZone, ...timeDisplayTuple ];
})(options), providedTimeZone = void 0 !== timeZoneArg;
return ((providedTimeZone, timeZoneOps, epochNano, roundingMode, nanoInc, subsecDigits) => {
epochNano = roundBigNanoByInc(epochNano, nanoInc, roundingMode, 1);
const offsetNano = timeZoneOps.getOffsetNanosecondsFor(epochNano);
return formatIsoDateTimeFields(epochNanoToIso(epochNano, offsetNano), subsecDigits) + (providedTimeZone ? formatOffsetNano(roundToMinute(offsetNano)) : "Z");
})(providedTimeZone, getTimeZoneOps(providedTimeZone ? refineTimeZoneString(timeZoneArg) : utcTimeZoneId), instantSlots.epochNanoseconds, roundingMode, nanoInc, subsecDigits);
}
function formatZonedDateTimeIso(getTimeZoneOps, zonedDateTimeSlots0, options) {
const [a, b, c, d, e, f] = (options => {
options = normalizeOptions(options);
const calendarDisplay = refineCalendarDisplay(options), subsecDigits = refineSubsecDigits(options), offsetDisplay = refineOffsetDisplay(options), roundingMode = refineRoundingMode(options, 4), smallestUnit = refineSmallestUnit(options, 4);
return [ calendarDisplay, refineTimeZoneDisplay(options), offsetDisplay, roundingMode, ...refineSmallestUnitAndSubsecDigits(smallestUnit, subsecDigits) ];
})(options);
return ((getTimeZoneOps, calendarId, timeZoneId, epochNano, calendarDisplay, timeZoneDisplay, offsetDisplay, roundingMode, nanoInc, subsecDigits) => {
epochNano = roundBigNanoByInc(epochNano, nanoInc, roundingMode, 1);
const offsetNano = getTimeZoneOps(timeZoneId).getOffsetNanosecondsFor(epochNano);
return formatIsoDateTimeFields(epochNanoToIso(epochNano, offsetNano), subsecDigits) + formatOffsetNano(roundToMinute(offsetNano), offsetDisplay) + ((timeZoneId, timeZoneDisplay) => 1 !== timeZoneDisplay ? "[" + (2 === timeZoneDisplay ? "!" : "") + timeZoneId + "]" : "")(timeZoneId, timeZoneDisplay) + formatCalendar(calendarId, calendarDisplay);
})(getTimeZoneOps, zonedDateTimeSlots0.calendar, zonedDateTimeSlots0.timeZone, zonedDateTimeSlots0.epochNanoseconds, a, b, c, d, e, f);
}
function formatPlainDateTimeIso(plainDateTimeSlots0, options) {
const [a, b, c, d] = (options => (options = normalizeOptions(options), [ refineCalendarDisplay(options), ...refineTimeDisplayTuple(options) ]))(options);
return calendarId = plainDateTimeSlots0.calendar, calendarDisplay = a, subsecDigits = d,
formatIsoDateTimeFields(roundDateTimeToNano(plainDateTimeSlots0, c, b), subsecDigits) + formatCalendar(calendarId, calendarDisplay);
var calendarId, calendarDisplay, subsecDigits;
}
function formatPlainDateIso(plainDateSlots, options) {
return calendarId = plainDateSlots.calendar, isoFields = plainDateSlots, calendarDisplay = refineDateDisplayOptions(options),
formatIsoDateFields(isoFields) + formatCalendar(calendarId, calendarDisplay);
var calendarId, isoFields, calendarDisplay;
}
function formatPlainYearMonthIso(plainYearMonthSlots, options) {
return formatDateLikeIso(plainYearMonthSlots.calendar, formatIsoYearMonthFields, plainYearMonthSlots, refineDateDisplayOptions(options));
}
function formatPlainMonthDayIso(plainMonthDaySlots, options) {
return formatDateLikeIso(plainMonthDaySlots.calendar, formatIsoMonthDayFields, plainMonthDaySlots, refineDateDisplayOptions(options));
}
function formatPlainTimeIso(slots, options) {
const [a, b, c] = refineTimeDisplayOptions(options);
return subsecDigits = c, formatIsoTimeFields(roundTimeToNano(slots, b, a)[0], subsecDigits);
var subsecDigits;
}
function formatDurationIso(slots, options) {
const [roundingMode, nanoInc, subsecDigits] = refineTimeDisplayOptions(options, 3);
return nanoInc > 1 && checkDurationUnits(slots = {
...slots,
...roundDayTimeDurationByInc(slots, nanoInc, roundingMode)
}), ((durationSlots, subsecDigits) => {
const {sign: sign} = durationSlots, abs = -1 === sign ? negateDurationFields(durationSlots) : durationSlots, {hours: hours, minutes: minutes} = abs, [wholeSec, subsecNano] = divModBigNano(durationFieldsToBigNano(abs, 3), nanoInSec, divModTrunc);
checkDurationTimeUnit(wholeSec);
const subsecNanoString = formatSubsecNano(subsecNano, subsecDigits), forceSec = subsecDigits >= 0 || !sign || subsecNanoString;
return (sign < 0 ? "-" : "") + "P" + formatDurationFragments({
Y: formatDurationNumber(abs.years),
M: formatDurationNumber(abs.months),
W: formatDurationNumber(abs.weeks),
D: formatDurationNumber(abs.days)
}) + (hours || minutes || wholeSec || forceSec ? "T" + formatDurationFragments({
H: formatDurationNumber(hours),
M: formatDurationNumber(minutes),
S: formatDurationNumber(wholeSec, forceSec) + subsecNanoString
}) : "");
})(slots, subsecDigits);
}
function formatDateLikeIso(calendarId, formatSimple, isoFields, calendarDisplay) {
const showCalendar = calendarDisplay > 1 || 0 === calendarDisplay && calendarId !== isoCalendarId;
return 1 === calendarDisplay ? calendarId === isoCalendarId ? formatSimple(isoFields) : formatIsoDateFields(isoFields) : showCalendar ? formatIsoDateFields(isoFields) + formatCalendarId(calendarId, 2 === calendarDisplay) : formatSimple(isoFields);
}
function formatDurationFragments(fragObj) {
const parts = [];
for (const fragName in fragObj) {
const fragVal = fragObj[fragName];
fragVal && parts.push(fragVal, fragName);
}
return parts.join("");
}
function formatIsoDateTimeFields(isoDateTimeFields, subsecDigits) {
return formatIsoDateFields(isoDateTimeFields) + "T" + formatIsoTimeFields(isoDateTimeFields, subsecDigits);
}
function formatIsoDateFields(isoDateFields) {
return formatIsoYearMonthFields(isoDateFields) + "-" + padNumber2(isoDateFields.isoDay);
}
function formatIsoYearMonthFields(isoDateFields) {
const {isoYear: isoYear} = isoDateFields;
return (isoYear < 0 || isoYear > 9999 ? getSignStr(isoYear) + padNumber(6, Math.abs(isoYear)) : padNumber(4, isoYear)) + "-" + padNumber2(isoDateFields.isoMonth);
}
function formatIsoMonthDayFields(isoDateFields) {
return padNumber2(isoDateFields.isoMonth) + "-" + padNumber2(isoDateFields.isoDay);
}
function formatIsoTimeFields(isoTimeFields, subsecDigits) {
const parts = [ padNumber2(isoTimeFields.isoHour), padNumber2(isoTimeFields.isoMinute) ];
return -1 !== subsecDigits && parts.push(padNumber2(isoTimeFields.isoSecond) + ((isoMillisecond, isoMicrosecond, isoNanosecond, subsecDigits) => formatSubsecNano(isoMillisecond * nanoInMilli + isoMicrosecond * nanoInMicro + isoNanosecond, subsecDigits))(isoTimeFields.isoMillisecond, isoTimeFields.isoMicrosecond, isoTimeFields.isoNanosecond, subsecDigits)),
parts.join(":");
}
function formatOffsetNano(offsetNano, offsetDisplay = 0) {
if (1 === offsetDisplay) {
return "";
}
const [hour, nanoRemainder0] = divModFloor(Math.abs(offsetNano), nanoInHour), [minute, nanoRemainder1] = divModFloor(nanoRemainder0, nanoInMinute), [second, nanoRemainder2] = divModFloor(nanoRemainder1, nanoInSec);
return getSignStr(offsetNano) + padNumber2(hour) + ":" + padNumber2(minute) + (second || nanoRemainder2 ? ":" + padNumber2(second) + formatSubsecNano(nanoRemainder2) : "");
}
function formatCalendar(calendarId, calendarDisplay) {
return 1 !== calendarDisplay && (calendarDisplay > 1 || 0 === calendarDisplay && calendarId !== isoCalendarId) ? formatCalendarId(calendarId, 2 === calendarDisplay) : "";
}
function formatCalendarId(calendarId, isCritical) {
return "[" + (isCritical ? "!" : "") + "u-ca=" + calendarId + "]";
}
function formatSubsecNano(totalNano, subsecDigits) {
let s = padNumber(9, totalNano);
return s = void 0 === subsecDigits ? s.replace(trailingZerosRE, "") : s.slice(0, subsecDigits),
s ? "." + s : "";
}
function getSignStr(num) {
return num < 0 ? "-" : "+";
}
function formatDurationNumber(n, force) {
return n || force ? n.toLocaleString("fullwide", {
useGrouping: 0
}) : "";
}
function getMatchingInstantFor(timeZoneOps, isoFields, offsetNano, offsetDisambig = 0, epochDisambig = 0, epochFuzzy, hasZ) {
if (void 0 !== offsetNano && 1 === offsetDisambig && (1 === offsetDisambig || hasZ)) {
return isoToEpochNanoWithOffset(isoFields, offsetNano);
}
const possibleEpochNanos = timeZoneOps.getPossibleInstantsFor(isoFields);
if (void 0 !== offsetNano && 3 !== offsetDisambig) {
const matchingEpochNano = ((possibleEpochNanos, isoDateTimeFields, offsetNano, fuzzy) => {
const zonedEpochNano = isoToEpochNano(isoDateTimeFields);
fuzzy && (offsetNano = roundToMinute(offsetNano));
for (const possibleEpochNano of possibleEpochNanos) {
let possibleOffsetNano = bigNanoToNumber(diffBigNanos(possibleEpochNano, zonedEpochNano));
if (fuzzy && (possibleOffsetNano = roundToMinute(possibleOffsetNano)), possibleOffsetNano === offsetNano) {
return possibleEpochNano;
}
}
})(possibleEpochNanos, isoFields, offsetNano, epochFuzzy);
if (void 0 !== matchingEpochNano) {
return matchingEpochNano;
}
if (0 === offsetDisambig) {
throw new RangeError(invalidOffsetForTimeZone);
}
}
return hasZ ? isoToEpochNano(isoFields) : getSingleInstantFor(timeZoneOps, isoFields, epochDisambig, possibleEpochNanos);
}
function getSingleInstantFor(timeZoneOps, isoFields, disambig = 0, possibleEpochNanos = timeZoneOps.getPossibleInstantsFor(isoFields)) {
if (1 === possibleEpochNanos.length) {
return possibleEpochNanos[0];
}
if (1 === disambig) {
throw new RangeError(ambigOffset);
}
if (possibleEpochNanos.length) {
return possibleEpochNanos[3 === disambig ? 1 : 0];
}
const zonedEpochNano = isoToEpochNano(isoFields), gapNano = ((timeZoneOps, zonedEpochNano) => {
const startOffsetNano = timeZoneOps.getOffsetNanosecondsFor(moveBigNano(zonedEpochNano, -nanoInUtcDay));
return (gapNano => {
if (gapNano > nanoInUtcDay) {
throw new RangeError(outOfBoundsDstGap);
}
return gapNano;
})(timeZoneOps.getOffsetNanosecondsFor(moveBigNano(zonedEpochNano, nanoInUtcDay)) - startOffsetNano);
})(timeZoneOps, zonedEpochNano), shiftNano = gapNano * (2 === disambig ? -1 : 1);
return (possibleEpochNanos = timeZoneOps.getPossibleInstantsFor(epochNanoToIso(zonedEpochNano, shiftNano)))[2 === disambig ? 0 : possibleEpochNanos.length - 1];
}
function getStartOfDayInstantFor(timeZoneOps, isoFields) {
const possibleEpochNanos = timeZoneOps.getPossibleInstantsFor(isoFields);
if (possibleEpochNanos.length) {
return possibleEpochNanos[0];
}
const zonedEpochNanoDayBefore = moveBigNano(isoToEpochNano(isoFields), -nanoInUtcDay);
return timeZoneOps.getTransition(zonedEpochNanoDayBefore, 1);
}
function moveInstant(doSubtract, instantSlots, durationSlots) {
return createInstantSlots(checkEpochNanoInBounds(addBigNanos(instantSlots.epochNanoseconds, (fields => {
if (durationHasDateParts(fields)) {
throw new RangeError(invalidLargeUnits);
}
return durationFieldsToBigNano(fields, 5);
})(doSubtract ? negateDurationFields(durationSlots) : durationSlots))));
}
function moveZonedDateTime(getCalendarOps, getTimeZoneOps, doSubtract, zonedDateTimeSlots, durationSlots, options = Object.create(null)) {
const timeZoneOps = getTimeZoneOps(zonedDateTimeSlots.timeZone), calendarOps = getCalendarOps(zonedDateTimeSlots.calendar);
return {
...zonedDateTimeSlots,
...moveZonedEpochs(timeZoneOps, calendarOps, zonedDateTimeSlots, doSubtract ? negateDurationFields(durationSlots) : durationSlots, options)
};
}
function movePlainDateTime(getCalendarOps, doSubtract, plainDateTimeSlots, durationSlots, options = Object.create(null)) {
const {calendar: calendar} = plainDateTimeSlots;
return createPlainDateTimeSlots(moveDateTime(getCalendarOps(calendar), plainDateTimeSlots, doSubtract ? negateDurationFields(durationSlots) : durationSlots, options), calendar);
}
function movePlainDate(getCalendarOps, doSubtract, plainDateSlots, durationSlots, options) {
const {calendar: calendar} = plainDateSlots;
return createPlainDateSlots(moveDate(getCalendarOps(calendar), plainDateSlots, doSubtract ? negateDurationFields(durationSlots) : durationSlots, options), calendar);
}
function movePlainYearMonth(getCalendarOps, doSubtract, plainYearMonthSlots, durationSlots, options) {
const calendarId = plainYearMonthSlots.calendar, calendarOps = getCalendarOps(calendarId);
let isoDateFields = checkIsoDateInBounds(moveToDayOfMonthUnsafe(calendarOps, plainYearMonthSlots));
doSubtract && (durationSlots = negateDuration(durationSlots)), durationSlots.sign < 0 && (isoDateFields = calendarOps.dateAdd(isoDateFields, {
...durationFieldDefaults,
months: 1
}), isoDateFields = moveByDays(isoDateFields, -1));
const movedIsoDateFields = calendarOps.dateAdd(isoDateFields, durationSlots, options);
return createPlainYearMonthSlots(moveToDayOfMonthUnsafe(calendarOps, movedIsoDateFields), calendarId);
}
function movePlainTime(doSubtract, slots, durationSlots) {
return createPlainTimeSlots(moveTime(slots, doSubtract ? negateDurationFields(durationSlots) : durationSlots)[0]);
}
function moveZonedEpochs(timeZoneOps, calendarOps, slots, durationFields, options) {
const timeOnlyNano = durationFieldsToBigNano(durationFields, 5);
let epochNano = slots.epochNanoseconds;
if (durationHasDateParts(durationFields)) {
const isoDateTimeFields = zonedEpochSlotsToIso(slots, timeZoneOps);
epochNano = addBigNanos(getSingleInstantFor(timeZoneOps, {
...moveDate(calendarOps, isoDateTimeFields, {
...durationFields,
...durationTimeFieldDefaults
}, options),
...pluckProps(isoTimeFieldNamesAsc, isoDateTimeFields)
}), timeOnlyNano);
} else {
epochNano = addBigNanos(epochNano, timeOnlyNano), refineOverflowOptions(options);
}
return {
epochNanoseconds: checkEpochNanoInBounds(epochNano)
};
}
function moveDateTime(calendarOps, isoDateTimeFields, durationFields, options) {
const [movedIsoTimeFields, dayDelta] = moveTime(isoDateTimeFields, durationFields);
return checkIsoDateTimeInBounds({
...moveDate(calendarOps, isoDateTimeFields, {
...durationFields,
...durationTimeFieldDefaults,
days: durationFields.days + dayDelta
}, options),
...movedIsoTimeFields
});
}
function moveDate(calendarOps, isoDateFields, durationFields, options) {
if (durationFields.years || durationFields.months || durationFields.weeks) {
return calendarOps.dateAdd(isoDateFields, durationFields, options);
}
refineOverflowOptions(options);
const days = durationFields.days + durationFieldsToBigNano(durationFields, 5)[0];
return days ? checkIsoDateInBounds(moveByDays(isoDateFields, days)) : isoDateFields;
}
function moveToDayOfMonthUnsafe(calendarOps, isoFields, dayOfMonth = 1) {
return moveByDays(isoFields, dayOfMonth - calendarOps.day(isoFields));
}
function moveTime(isoFields, durationFields) {
const [durDays, durTimeNano] = durationFieldsToBigNano(durationFields, 5), [newIsoFields, overflowDays] = nanoToIsoTimeAndDay(isoTimeFieldsToNano(isoFields) + durTimeNano);
return [ newIsoFields, durDays + overflowDays ];
}
function moveByDays(isoFields, days) {
return days ? {
...isoFields,
...epochMilliToIso(isoToEpochMilli(isoFields) + days * milliInDay)
} : isoFields;
}
function diffInstants(invert, instantSlots0, instantSlots1, options) {
const optionsTuple = refineDiffOptions(invert, options, 3, 5), durationFields = diffEpochNanos(instantSlots0.epochNanoseconds, instantSlots1.epochNanoseconds, ...optionsTuple);
return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
}
function diffZonedDateTimes(getCalendarOps, getTimeZoneOps, invert, slots0, slots1, options) {
const calendarId = getCommonCalendarId(slots0.calendar, slots1.calendar), [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 5), epochNano0 = slots0.epochNanoseconds, epochNano1 = slots1.epochNanoseconds, sign = compareBigNanos(epochNano1, epochNano0);
let durationFields;
if (sign) {
if (largestUnit < 6) {
durationFields = diffEpochNanos(epochNano0, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode);
} else {
const timeZoneOps = getTimeZoneOps(((a, b) => {
if (!isTimeZoneIdsEqual(a, b)) {
throw new RangeError(mismatchingTimeZones);
}
return a;
})(slots0.timeZone, slots1.timeZone)), calendarOps = getCalendarOps(calendarId);
durationFields = diffZonedEpochsBig(calendarOps, timeZoneOps, slots0, slots1, sign, largestUnit, options),
durationFields = roundRelativeDuration(durationFields, epochNano1, largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, slots0, extractEpochNano, bindArgs(moveZonedEpochs, timeZoneOps));
}
} else {
durationFields = durationFieldDefaults;
}
return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
}
function diffPlainDateTimes(getCalendarOps, invert, plainDateTimeSlots0, plainDateTimeSlots1, options) {
const calendarId = getCommonCalendarId(plainDateTimeSlots0.calendar, plainDateTimeSlots1.calendar), [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 6), startEpochNano = isoToEpochNano(plainDateTimeSlots0), endEpochNano = isoToEpochNano(plainDateTimeSlots1), sign = compareBigNanos(endEpochNano, startEpochNano);
let durationFields;
if (sign) {
if (largestUnit <= 6) {
durationFields = diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode);
} else {
const calendarOps = getCalendarOps(calendarId);
durationFields = diffDateTimesBig(calendarOps, plainDateTimeSlots0, plainDateTimeSlots1, sign, largestUnit, options),
durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, plainDateTimeSlots0, isoToEpochNano, moveDateTime);
}
} else {
durationFields = durationFieldDefaults;
}
return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
}
function diffPlainDates(getCalendarOps, invert, plainDateSlots0, plainDateSlots1, options) {
const calendarId = getCommonCalendarId(plainDateSlots0.calendar, plainDateSlots1.calendar);
return diffDateLike(invert, (() => getCalendarOps(calendarId)), plainDateSlots0, plainDateSlots1, ...refineDiffOptions(invert, options, 6, 9, 6));
}
function diffPlainYearMonth(getCalendarOps, invert, plainYearMonthSlots0, plainYearMonthSlots1, options) {
const calendarId = getCommonCalendarId(plainYearMonthSlots0.calendar, plainYearMonthSlots1.calendar), optionsTuple = refineDiffOptions(invert, options, 9, 9, 8), calendarOps = getCalendarOps(calendarId), firstOfMonth0 = moveToDayOfMonthUnsafe(calendarOps, plainYearMonthSlots0), firstOfMonth1 = moveToDayOfMonthUnsafe(calendarOps, plainYearMonthSlots1);
return firstOfMonth0.isoYear === firstOfMonth1.isoYear && firstOfMonth0.isoMonth === firstOfMonth1.isoMonth && firstOfMonth0.isoDay === firstOfMonth1.isoDay ? createDurationSlots(durationFieldDefaults) : diffDateLike(invert, (() => calendarOps), checkIsoDateInBounds(firstOfMonth0), checkIsoDateInBounds(firstOfMonth1), ...optionsTuple, 8);
}
function diffDateLike(invert, getCalendarOps, startIsoFields, endIsoFields, largestUnit, smallestUnit, roundingInc, roundingMode, smallestPrecision = 6) {
const startEpochNano = isoToEpochNano(startIsoFields), endEpochNano = isoToEpochNano(endIsoFields);
if (void 0 === startEpochNano || void 0 === endEpochNano) {
throw new RangeError(outOfBoundsDate);
}
let durationFields;
if (compareBigNanos(endEpochNano, startEpochNano)) {
if (6 === largestUnit) {
durationFields = diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode);
} else {
const calendarOps = getCalendarOps();
durationFields = calendarOps.dateUntil(startIsoFields, endIsoFields, largestUnit),
smallestUnit === smallestPrecision && 1 === roundingInc || (durationFields = roundRelativeDuration(durationFields, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, startIsoFields, isoToEpochNano, moveDate));
}
} else {
durationFields = durationFieldDefaults;
}
return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
}
function diffPlainTimes(invert, plainTimeSlots0, plainTimeSlots1, options) {
const [largestUnit, smallestUnit, roundingInc, roundingMode] = refineDiffOptions(invert, options, 5, 5), timeDiffNano = roundByInc(diffTimes(plainTimeSlots0, plainTimeSlots1), computeNanoInc(smallestUnit, roundingInc), roundingMode), durationFields = {
...durationFieldDefaults,
...nanoToDurationTimeFields(timeDiffNano, largestUnit)
};
return createDurationSlots(invert ? negateDurationFields(durationFields) : durationFields);
}
function diffZonedEpochsExact(timeZoneOps, calendarOps, slots0, slots1, largestUnit, origOptions) {
const sign = compareBigNanos(slots1.epochNanoseconds, slots0.epochNanoseconds);
return sign ? largestUnit < 6 ? diffEpochNanosExact(slots0.epochNanoseconds, slots1.epochNanoseconds, largestUnit) : diffZonedEpochsBig(calendarOps, timeZoneOps, slots0, slots1, sign, largestUnit, origOptions) : durationFieldDefaults;
}
function diffDateTimesExact(calendarOps, startIsoFields, endIsoFields, largestUnit, origOptions) {
const startEpochNano = isoToEpochNano(startIsoFields), endEpochNano = isoToEpochNano(endIsoFields), sign = compareBigNanos(endEpochNano, startEpochNano);
return sign ? largestUnit <= 6 ? diffEpochNanosExact(startEpochNano, endEpochNano, largestUnit) : diffDateTimesBig(calendarOps, startIsoFields, endIsoFields, sign, largestUnit, origOptions) : durationFieldDefaults;
}
function diffZonedEpochsBig(calendarOps, timeZoneOps, slots0, slots1, sign, largestUnit, origOptions) {
const [isoFields0, isoFields1, remainderNano] = ((timeZoneOps, slots0, slots1, sign) => {
function updateMid() {
return midIsoFields = {
...moveByDays(endIsoFields, dayCorrection++ * -sign),
...startIsoTimeFields
}, midEpochNano = getSingleInstantFor(timeZoneOps, midIsoFields), compareBigNanos(endEpochNano, midEpochNano) === -sign;
}
const startIsoFields = zonedEpochSlotsToIso(slots0, timeZoneOps), startIsoTimeFields = pluckProps(isoTimeFieldNamesAsc, startIsoFields), endIsoFields = zonedEpochSlotsToIso(slots1, timeZoneOps), endEpochNano = slots1.epochNanoseconds;
let dayCorrection = 0;
const timeDiffNano = diffTimes(startIsoFields, endIsoFields);
let midIsoFields, midEpochNano;
if (Math.sign(timeDiffNano) === -sign && dayCorrection++, updateMid() && (-1 === sign || updateMid())) {
throw new RangeError(invalidProtocolResults);
}
const remainderNano = bigNanoToNumber(diffBigNanos(midEpochNano, endEpochNano));
return [ startIsoFields, midIsoFields, remainderNano ];
})(timeZoneOps, slots0, slots1, sign);
var startIsoFields, endIsoFields;
return {
...6 === largestUnit ? (startIsoFields = isoFields0, endIsoFields = isoFields1,
{
...durationFieldDefaults,
days: diffDays(startIsoFields, endIsoFields)
}) : calendarOps.dateUntil(isoFields0, isoFields1, largestUnit, origOptions),
...nanoToDurationTimeFields(remainderNano)
};
}
function diffDateTimesBig(calendarOps, startIsoFields, endIsoFields, sign, largestUnit, origOptions) {
const [startIsoDate, endIsoDate, timeNano] = ((startIsoDateTime, endIsoDateTime, sign) => {
let endIsoDate = endIsoDateTime, timeDiffNano = diffTimes(startIsoDateTime, endIsoDateTime);
return Math.sign(timeDiffNano) === -sign && (endIsoDate = moveByDays(endIsoDateTime, -sign),
timeDiffNano += nanoInUtcDay * sign), [ startIsoDateTime, endIsoDate, timeDiffNano ];
})(startIsoFields, endIsoFields, sign);
return {
...calendarOps.dateUntil(startIsoDate, endIsoDate, largestUnit, origOptions),
...nanoToDurationTimeFields(timeNano)
};
}
function diffEpochNanos(startEpochNano, endEpochNano, largestUnit, smallestUnit, roundingInc, roundingMode) {
return {
...durationFieldDefaults,
...nanoToDurationDayTimeFields(roundBigNano(diffBigNanos(startEpochNano, endEpochNano), smallestUnit, roundingInc, roundingMode), largestUnit)
};
}
function diffEpochNanosExact(startEpochNano, endEpochNano, largestUnit) {
return {
...durationFieldDefaults,
...nanoToDurationDayTimeFields(diffBigNanos(startEpochNano, endEpochNano), largestUnit)
};
}
function diffDays(startIsoFields, endIsoFields) {
return diffEpochMilliByDay(isoToEpochMilli(startIsoFields), isoToEpochMilli(endIsoFields));
}
function diffEpochMilliByDay(epochMilli0, epochMilli1) {
return Math.trunc((epochMilli1 - epochMilli0) / milliInDay);
}
function diffTimes(isoTime0, isoTime1) {
return isoTimeFieldsToNano(isoTime1) - isoTimeFieldsToNano(isoTime0);
}
function getCommonCalendarId(a, b) {
if (a !== b) {
throw new RangeError(mismatchingCalendars);
}
return a;
}
function createMarkerSystem(getCalendarOps, getTimeZoneOps, relativeToSlots) {
const calendarOps = getCalendarOps(relativeToSlots.calendar);
return isZonedEpochSlots(relativeToSlots) ? [ relativeToSlots, calendarOps, getTimeZoneOps(relativeToSlots.timeZone) ] : [ {
...relativeToSlots,
...isoTimeFieldDefaults
}, calendarOps ];
}
function createMarkerToEpochNano(timeZoneOps) {
return timeZoneOps ? extractEpochNano : isoToEpochNano;
}
function createMoveMarker(timeZoneOps) {
return timeZoneOps ? bindArgs(moveZonedEpochs, timeZoneOps) : moveDateTime;
}
function createDiffMarkers(timeZoneOps) {
return timeZoneOps ? bindArgs(diffZonedEpochsExact, timeZoneOps) : diffDateTimesExact;
}
function isZonedEpochSlots(marker) {
return marker && marker.epochNanoseconds;
}
function isUniformUnit(unit, marker) {
return unit <= 6 - (isZonedEpochSlots(marker) ? 1 : 0);
}
function addDurations(refineRelativeTo, getCalendarOps, getTimeZoneOps, doSubtract, slots, otherSlots, options) {
const relativeToSlots = refineRelativeTo(normalizeOptions(options).relativeTo), maxUnit = Math.max(getMaxDurationUnit(slots), getMaxDurationUnit(otherSlots));
if (isUniformUnit(maxUnit, relativeToSlots)) {
return createDurationSlots(checkDurationUnits(((a, b, largestUnit, doSubtract) => {
const combined = addBigNanos(durationFieldsToBigNano(a), durationFieldsToBigNano(b), doSubtract ? -1 : 1);
if (!Number.isFinite(combined[0])) {
throw new RangeError(outOfBoundsDate);
}
return {
...durationFieldDefaults,
...nanoToDurationDayTimeFields(combined, largestUnit)
};
})(slots, otherSlots, maxUnit, doSubtract)));
}
if (!relativeToSlots) {
throw new RangeError("Missing relativeTo");
}
doSubtract && (otherSlots = negateDurationFields(otherSlots));
const [marker, calendarOps, timeZoneOps] = createMarkerSystem(getCalendarOps, getTimeZoneOps, relativeToSlots), moveMarker = createMoveMarker(timeZoneOps), diffMarkers = createDiffMarkers(timeZoneOps), midMarker = moveMarker(calendarOps, marker, slots);
return createDurationSlots(diffMarkers(calendarOps, marker, moveMarker(calendarOps, midMarker, otherSlots), maxUnit));
}
function negateDuration(slots) {
return createDurationSlots(negateDurationFields(slots));
}
function negateDurationFields(fields) {
const res = {};
for (const fieldName of durationFieldNamesAsc) {
res[fieldName] = -1 * fields[fieldName] || 0;
}
return res;
}
function computeDurationSign(fields, fieldNames = durationFieldNamesAsc) {
let sign = 0;
for (const fieldName of fieldNames) {
const fieldSign = Math.sign(fields[fieldName]);
if (fieldSign) {
if (sign && sign !== fieldSign) {
throw new RangeError(forbiddenDurationSigns);
}
sign = fieldSign;
}
}
return sign;
}
function checkDurationUnits(fields) {
for (const calendarUnit of durationCalendarFieldNamesAsc) {
clampEntity(calendarUnit, fields[calendarUnit], -maxCalendarUnit, maxCalendarUnit, 1);
}
return checkDurationTimeUnit(bigNanoToNumber(durationFieldsToBigNano(fields), nanoInSec)),
fields;
}
function checkDurationTimeUnit(n) {
if (!Number.isSafeInteger(n)) {
throw new RangeError(outOfBoundsDuration);
}
}
function durationFieldsToBigNano(fields, largestUnit = 6) {
return givenFieldsToBigNano(fields, largestUnit, durationFieldNamesAsc);
}
function nanoToDurationDayTimeFields(bigNano, largestUnit = 6) {
const [days, timeNano] = bigNano, dayTimeFields = nanoToGivenFields(timeNano, largestUnit, durationFieldNamesAsc);
if (dayTimeFields[durationFieldNamesAsc[largestUnit]] += days * (nanoInUtcDay / unitNanoMap[largestUnit]),
!Number.isFinite(dayTimeFields[durationFieldNamesAsc[largestUnit]])) {
throw new RangeError(outOfBoundsDate);
}
return dayTimeFields;
}
function nanoToDurationTimeFields(nano, largestUnit = 5) {
return nanoToGivenFields(nano, largestUnit, durationFieldNamesAsc);
}
function durationHasDateParts(fields) {
return Boolean(computeDurationSign(fields, durationDateFieldNamesAsc));
}
function getMaxDurationUnit(fields) {
let unit = 9;
for (;unit > 0 && !fields[durationFieldNamesAsc[unit]]; unit--) {}
return unit;
}
function createSplitTuple(startEpochSec, endEpochSec) {
return [ startEpochSec, endEpochSec ];
}
function computePeriod(epochSec) {
const startEpochSec = Math.floor(epochSec / periodDur) * periodDur;
return [ startEpochSec, startEpochSec + periodDur ];
}
function parseOffsetNano(s) {
const offsetNano = parseOffsetNanoMaybe(s);
if (void 0 === offsetNano) {
throw new RangeError(failedParse(s));
}
return offsetNano;
}
function parsePlainDate(s, isPlainYearMonth, isPlainMonthDay) {
let organized = parseDateTimeLike(requireString(s));
if (!organized || organized.hasZ) {
throw new RangeError(failedParse(s));
}
return isPlainYearMonth ? organized.calendar === isoCalendarId && (organized = -271821 === organized.isoYear && 4 === organized.isoMonth ? {
...organized,
isoDay: 20,
...isoTimeFieldDefaults
} : {
...organized,
isoDay: 1,
...isoTimeFieldDefaults
}) : isPlainMonthDay && organized.calendar === isoCalendarId && (organized = {
...organized,
isoYear: isoEpochFirstLeapYear
}), createPlainDateSlots(organized.hasTime ? finalizeDateTime(organized) : finalizeDate(organized));
}
function requireIsoCalendar(organized) {
if (organized.calendar !== isoCalendarId) {
throw new RangeError(invalidSubstring(organized.calendar));
}
}
function finalizeZonedDateTime(organized, offsetNano, offsetDisambig = 0, epochDisambig = 0) {
const timeZoneId = resolveTimeZoneId(organized.timeZone), timeZoneImpl = queryNativeTimeZone(timeZoneId);
let epochNano;
return checkIsoDateTimeFields(organized), epochNano = organized.hasTime ? getMatchingInstantFor(timeZoneImpl, organized, offsetNano, offsetDisambig, epochDisambig, !timeZoneImpl.offsetNano, organized.hasZ) : getStartOfDayInstantFor(timeZoneImpl, organized),
createZonedDateTimeSlots(epochNano, timeZoneId, resolveCalendarId(organized.calendar));
}
function finalizeDateTime(organized) {
return resolveSlotsCalendar(checkIsoDateTimeInBounds(checkIsoDateTimeFields(organized)));
}
function finalizeDate(organized) {
return resolveSlotsCalendar(checkIsoDateInBounds(checkIsoDateFields(organized)));
}
function resolveSlotsCalendar(organized) {
return {
...organized,
calendar: resolveCalendarId(organized.calendar)
};
}
function parseDateTimeLike(s) {
const parts = dateTimeRegExp.exec(s);
return parts ? (parts => {
const zOrOffset = parts[10], hasZ = "Z" === (zOrOffset || "").toUpperCase();
return {
isoYear: organizeIsoYearParts(parts),
isoMonth: parseInt(parts[4]),
isoDay: parseInt(parts[5]),
...organizeTimeParts(parts.slice(5)),
...organizeAnnotationParts(parts[16]),
hasTime: Boolean(parts[6]),
hasZ: hasZ,
offset: hasZ ? void 0 : zOrOffset
};
})(parts) : void 0;
}
function parseYearMonthOnly(s) {
const parts = yearMonthRegExp.exec(s);
return parts ? (parts => ({
isoYear: organizeIsoYearParts(parts),
isoMonth: parseInt(parts[4]),
isoDay: 1,
...organizeAnnotationParts(parts[5])
}))(parts) : void 0;
}
function parseMonthDayOnly(s) {
const parts = monthDayRegExp.exec(s);
return parts ? (parts => ({
isoYear: isoEpochFirstLeapYear,
isoMonth: parseInt(parts[1]),
isoDay: parseInt(parts[2]),
...organizeAnnotationParts(parts[3])
}))(parts) : void 0;
}
function parseOffsetNanoMaybe(s, onlyHourMinute) {
const parts = offsetRegExp.exec(s);
return parts ? ((parts, onlyHourMinute) => {
const firstSubMinutePart = parts[4] || parts[5];
if (onlyHourMinute && firstSubMinutePart) {
throw new RangeError(invalidSubstring(firstSubMinutePart));
}
return (offsetNano => {
if (Math.abs(offsetNano) >= nanoInUtcDay) {
throw new RangeError(outOfBoundsOffset);
}
return offsetNano;
})((parseInt0(parts[2]) * nanoInHour + parseInt0(parts[3]) * nanoInMinute + parseInt0(parts[4]) * nanoInSec + parseSubsecNano(parts[5] || "")) * parseSign(parts[1]));
})(parts, onlyHourMinute) : void 0;
}
function organizeIsoYearParts(parts) {
const yearSign = parseSign(parts[1]), year = parseInt(parts[2] || parts[3]);
if (yearSign < 0 && !year) {
throw new RangeError(invalidSubstring(-0));
}
return yearSign * year;
}
function organizeTimeParts(parts) {
const isoSecond = parseInt0(parts[3]);
return {
...nanoToIsoTimeAndDay(parseSubsecNano(parts[4] || ""))[0],
isoHour: parseInt0(parts[1]),
isoMinute: parseInt0(parts[2]),
isoSecond: 60 === isoSecond ? 59 : isoSecond
};
}
function organizeAnnotationParts(s) {
let calendarIsCritical, timeZoneId;
const calendarIds = [];
if (s.replace(annotationRegExp, ((whole, criticalStr, mainStr) => {
const isCritical = Boolean(criticalStr), [val, name] = mainStr.split("=").reverse();
if (name) {
if ("u-ca" === name) {
calendarIds.push(val), calendarIsCritical || (calendarIsCritical = isCritical);
} else if (isCritical || /[A-Z]/.test(name)) {
throw new RangeError(invalidSubstring(whole));
}
} else {
if (timeZoneId) {
throw new RangeError(invalidSubstring(whole));
}
timeZoneId = val;
}
return "";
})), calendarIds.length > 1 && calendarIsCritical) {
throw new RangeError(invalidSubstring(s));
}
return {
timeZone: timeZoneId,
calendar: calendarIds[0] || isoCalendarId
};
}
function parseSubsecNano(fracStr) {
return parseInt(fracStr.padEnd(9, "0"));
}
function createRegExp(meat) {
return new RegExp(`^${meat}$`, "i");
}
function parseSign(s) {
return s && "+" !== s ? -1 : 1;
}
function parseInt0(s) {
return void 0 === s ? 0 : parseInt(s);
}
function resolveTimeZoneId(id) {
const essence = getTimeZoneEssence(id);
return "number" == typeof essence ? formatOffsetNano(essence) : essence ? (id => {
if (badCharactersRegExp.test(id)) {
throw new RangeError(invalidTimeZone(id));
}
if (icuRegExp.test(id)) {
throw new RangeError(forbiddenIcuTimeZone);
}
return id.toLowerCase().split("/").map(((part, partI) => (part.length <= 3 || /\d/.test(part)) && !/etc|yap/.test(part) ? part.toUpperCase() : part.replace(/baja|dumont|[a-z]+/g, ((a, i) => a.length <= 2 && !partI || "in" === a || "chat" === a ? a.toUpperCase() : a.length > 2 || !i ? capitalize(a).replace(/island|noronha|murdo|rivadavia|urville/, capitalize) : a)))).join("/");
})(id) : utcTimeZoneId;
}
function getTimeZoneAtomic(id) {
const essence = getTimeZoneEssence(id);
return "number" == typeof essence ? essence : essence ? essence.resolvedOptions().timeZone : utcTimeZoneId;
}
function getTimeZoneEssence(id) {
const offsetNano = parseOffsetNanoMaybe(id = id.toUpperCase(), 1);
return void 0 !== offsetNano ? offsetNano : id !== utcTimeZoneId ? queryTimeZoneIntlFormat(id) : void 0;
}
function compareInstants(instantSlots0, instantSlots1) {
return compareBigNanos(instantSlots0.epochNanoseconds, instantSlots1.epochNanoseconds);
}
function compareZonedDateTimes(zonedDateTimeSlots0, zonedDateTimeSlots1) {
return compareBigNanos(zonedDateTimeSlots0.epochNanoseconds, zonedDateTimeSlots1.epochNanoseconds);
}
function compareIsoDateTimeFields(isoFields0, isoFields1) {
return compareIsoDateFields(isoFields0, isoFields1) || compareIsoTimeFields(isoFields0, isoFields1);
}
function compareIsoDateFields(isoFields0, isoFields1) {
return compareNumbers(isoToEpochMilli(isoFields0), isoToEpochMilli(isoFields1));
}
function compareIsoTimeFields(isoFields0, isoFields1) {
return compareNumbers(isoTimeFieldsToNano(isoFields0), isoTimeFieldsToNano(isoFields1));
}
function isTimeZoneIdsEqual(a, b) {
if (a === b) {
return 1;
}
try {
return getTimeZoneAtomic(a) === getTimeZoneAtomic(b);
} catch (_a) {}
}
function createNativeOpsCreator(isoOps, intlOps) {
return calendarId => calendarId === isoCalendarId ? isoOps : calendarId === gregoryCalendarId || "japanese" === calendarId ? Object.assign(Object.create(isoOps), {
id: calendarId
}) : Object.assign(Object.create(intlOps), queryIntlCalendar(calendarId));
}
function refineCalendarFields(calendarOps, bag, validFieldNames, requiredFieldNames = [], forcedValidFieldNames = []) {
return refineFields(bag, [ ...calendarOps.fields(validFieldNames), ...forcedValidFieldNames ].sort(), requiredFieldNames);
}
function refineFields(bag, validFieldNames, requiredFieldNames, disallowEmpty = !requiredFieldNames) {
const res = {};
let prevFieldName, anyMatching = 0;
for (const fieldName of validFieldNames) {
if (fieldName === prevFieldName) {
throw new RangeError(duplicateFields(fieldName));
}
if ("constructor" === fieldName || "__proto__" === fieldName) {
throw new RangeError(forbiddenField(fieldName));
}
let fieldVal = bag[fieldName];
if (void 0 !== fieldVal) {
anyMatching = 1, builtinRefiners[fieldName] && (fieldVal = builtinRefiners[fieldName](fieldVal, fieldName)),
res[fieldName] = fieldVal;
} else if (requiredFieldNames) {
if (requiredFieldNames.includes(fieldName)) {
throw new TypeError(missingField(fieldName));
}
res[fieldName] = timeFieldDefaults[fieldName];
}
prevFieldName = fieldName;
}
if (disallowEmpty && !anyMatching) {
throw new TypeError(noValidFields(validFieldNames));
}
return res;
}
function refineTimeBag(fields, overflow) {
return constrainIsoTimeFields(timeFieldsToIso({
...timeFieldDefaults,
...fields
}), overflow);
}
function convertToIso(calendarOps, input, inputFieldNames, extra, extraFieldNames) {
input = pluckProps(inputFieldNames = calendarOps.fields(inputFieldNames), input),
extra = refineFields(extra, extraFieldNames = calendarOps.fields(extraFieldNames), []);
let mergedFields = calendarOps.mergeFields(input, extra);
return mergedFields = refineFields(mergedFields, [ ...inputFieldNames, ...extraFieldNames ].sort(), []),
calendarOps.dateFromFields(mergedFields);
}
function refineYear(calendarNative, fields) {
const eraOrigins = getCalendarEraOrigins(calendarNative), eraRemaps = eraRemapsByCalendarId[calendarNative.id || ""] || {};
let {era: era, eraYear: eraYear, year: year} = fields;
if (void 0 !== era || void 0 !== eraYear) {
if (void 0 === era || void 0 === eraYear) {
throw new TypeError(mismatchingEraParts);
}
if (!eraOrigins) {
throw new RangeError(forbiddenEraParts);
}
const eraOrigin = eraOrigins[eraRemaps[era] || era];
if (void 0 === eraOrigin) {
throw new RangeError(invalidEra(era));
}
const yearByEra = eraYearToYear(eraYear, eraOrigin);
if (void 0 !== year && year !== yearByEra) {
throw new RangeError(mismatchingYearAndEra);
}
year = yearByEra;
} else if (void 0 === year) {
throw new TypeError(missingYear(eraOrigins));
}
return year;
}
function refineMonth(calendarNative, fields, year, overflow) {
let {month: month, monthCode: monthCode} = fields;
if (void 0 !== monthCode) {
const monthByCode = ((calendarNative, monthCode, year, overflow) => {
const leapMonth = calendarNative.leapMonth(year), [monthCodeNumber, wantsLeapMonth] = parseMonthCode(monthCode);
let month = monthCodeNumberToMonth(monthCodeNumber, wantsLeapMonth, leapMonth);
if (wantsLeapMonth) {
const leapMonthMeta = getCalendarLeapMonthMeta(calendarNative);
if (void 0 === leapMonthMeta) {
throw new RangeError(invalidLeapMonth);
}
if (leapMonthMeta > 0) {
if (month > leapMonthMeta) {
throw new RangeError(invalidLeapMonth);
}
if (void 0 === leapMonth) {
if (1 === overflow) {
throw new RangeError(invalidLeapMonth);
}
month--;
}
} else {
if (month !== -leapMonthMeta) {
throw new RangeError(invalidLeapMonth);
}
if (void 0 === leapMonth && 1 === overflow) {
throw new RangeError(invalidLeapMonth);
}
}
}
return month;
})(calendarNative, monthCode, year, overflow);
if (void 0 !== month && month !== monthByCode) {
throw new RangeError(mismatchingMonthAndCode);
}
month = monthByCode, overflow = 1;
} else if (void 0 === month) {
throw new TypeError(missingMonth);
}
return clampEntity("month", month, 1, calendarNative.monthsInYearPart(year), overflow);
}
function refineDay(calendarNative, fields, month, year, overflow) {
return clampProp(fields, "day", 1, calendarNative.daysInMonthParts(year, month), overflow);
}
function spliceFields(dest, additional, allPropNames, deletablePropNames) {
let anyMatching = 0;
const nonMatchingPropNames = [];
for (const propName of allPropNames) {
void 0 !== additional[propName] ? anyMatching = 1 : nonMatchingPropNames.push(propName);
}
if (Object.assign(dest, additional), anyMatching) {
for (const deletablePropName of deletablePropNames || nonMatchingPropNames) {
delete dest[deletablePropName];
}
}
}
function computeDateEssentials(slots) {
const calendarOps = createNativePartOps(slots.calendar), [year, month, day] = calendarOps.dateParts(slots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month);
return {
year: year,
monthCode: formatMonthCode(monthCodeNumber, isLeapMonth),
day: day
};
}
function zonedDateTimeToPlainDateTime(getTimeZoneOps, zonedDateTimeSlots0) {
return createPlainDateTimeSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0, getTimeZoneOps));
}
function zonedDateTimeToPlainDate(getTimeZoneOps, zonedDateTimeSlots0) {
return createPlainDateSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0, getTimeZoneOps));
}
function zonedDateTimeToPlainTime(getTimeZoneOps, zonedDateTimeSlots0) {
return createPlainTimeSlots(zonedEpochSlotsToIso(zonedDateTimeSlots0, getTimeZoneOps));
}
function createSlotClass(branding, construct, getters, methods, staticMethods) {
function Class(...args) {
if (!(this instanceof Class)) {
throw new TypeError("Invalid calling context");
}
setSlots(this, construct(...args));
}
function bindMethod(method, methodName) {
return Object.defineProperties((function(...args) {
return method.call(this, getSpecificSlots(this), ...args);
}), createNameDescriptors(methodName));
}
function getSpecificSlots(obj) {
const slots = getSlots(obj);
if (!slots || slots.branding !== branding) {
throw new TypeError("Invalid calling context");
}
return slots;
}
return Object.defineProperties(Class.prototype, {
...createGetterDescriptors(mapProps(bindMethod, getters)),
...createPropDescriptors(mapProps(bindMethod, methods)),
...createStringTagDescriptors("Temporal." + branding)
}), Object.defineProperties(Class, {
...createPropDescriptors(staticMethods),
...createNameDescriptors(branding)
}), [ Class, slots => {
const instance = Object.create(Class.prototype);
return setSlots(instance, slots), instance;
}, getSpecificSlots ];
}
function rejectInvalidBag(bag) {
if (getSlots(bag) || void 0 !== bag.calendar || void 0 !== bag.timeZone) {
throw new TypeError("Invalid bag");
}
return bag;
}
function getCalendarIdFromBag(bag) {
return extractCalendarIdFromBag(bag) || isoCalendarId;
}
function extractCalendarIdFromBag(bag) {
const {calendar: calendarArg} = bag;
if (void 0 !== calendarArg) {
return refineCalendarArg(calendarArg);
}
}
function refineCalendarArg(arg) {
if (isObjectLike(arg)) {
const {calendar: calendar} = getSlots(arg) || {};
if (!calendar) {
throw new TypeError(invalidCalendar(arg));
}
return calendar;
}
return (arg => resolveCalendarId((s => {
const res = parseDateTimeLike(s) || parseYearMonthOnly(s) || parseMonthDayOnly(s);
return res ? res.calendar : s;
})(requireString(arg))))(arg);
}
function createCalendarGetters(methodNameMap) {
const methods = {};
for (const methodName in methodNameMap) {
methods[methodName] = slots => {
const {calendar: calendar} = slots;
return createNativeStandardOps(calendar)[methodName](slots);
};
}
return methods;
}
function neverValueOf() {
throw new TypeError("Cannot use valueOf");
}
function refineTimeZoneArg(arg) {
if (isObjectLike(arg)) {
const {timeZone: timeZone} = getSlots(arg) || {};
if (!timeZone) {
throw new TypeError(invalidTimeZone(arg));
}
return timeZone;
}
return (arg => resolveTimeZoneId((s => {
const parsed = parseDateTimeLike(s);
return parsed && (parsed.timeZone || parsed.hasZ && utcTimeZoneId || parsed.offset) || s;
})(requireString(arg))))(arg);
}
function toDurationSlots(arg) {
if (isObjectLike(arg)) {
const slots = getSlots(arg);
return slots && slots.branding === DurationBranding ? slots : (bag => {
const durationFields = refineFields(bag, durationFieldNamesAlpha);
return createDurationSlots(checkDurationUnits({
...durationFieldDefaults,
...durationFields
}));
})(arg);
}
return (s => {
const parsed = (s => {
const parts = durationRegExp.exec(s);
return parts ? (parts => {
function parseUnit(wholeStr, fracStr, timeUnit) {
let leftoverUnits = 0, wholeUnits = 0;
if (timeUnit && ([leftoverUnits, leftoverNano] = divModFloor(leftoverNano, unitNanoMap[timeUnit])),
void 0 !== wholeStr) {
if (hasAnyFrac) {
throw new RangeError(invalidSubstring(wholeStr));
}
wholeUnits = (s => {
const n = parseInt(s);
if (!Number.isFinite(n)) {
throw new RangeError(invalidSubstring(s));
}
return n;
})(wholeStr), hasAny = 1, fracStr && (leftoverNano = parseSubsecNano(fracStr) * (unitNanoMap[timeUnit] / nanoInSec),
hasAnyFrac = 1);
}
return leftoverUnits + wholeUnits;
}
let hasAny = 0, hasAnyFrac = 0, leftoverNano = 0, durationFields = {
...zipProps(durationFieldNamesAsc, [ parseUnit(parts[2]), parseUnit(parts[3]), parseUnit(parts[4]), parseUnit(parts[5]), parseUnit(parts[6], parts[7], 5), parseUnit(parts[8], parts[9], 4), parseUnit(parts[10], parts[11], 3) ]),
...nanoToGivenFields(leftoverNano, 2, durationFieldNamesAsc)
};
if (!hasAny) {
throw new RangeError(noValidFields(durationFieldNamesAsc));
}
return parseSign(parts[1]) < 0 && (durationFields = negateDurationFields(durationFields)),
durationFields;
})(parts) : void 0;
})(requireString(s));
if (!parsed) {
throw new RangeError(failedParse(s));
}
return createDurationSlots(checkDurationUnits(parsed));
})(arg);
}
function refinePublicRelativeTo(relativeTo) {
if (void 0 !== relativeTo) {
if (isObjectLike(relativeTo)) {
const slots = getSlots(relativeTo) || {};
switch (slots.branding) {
case ZonedDateTimeBranding:
case PlainDateBranding:
return slots;
case PlainDateTimeBranding:
return createPlainDateSlots(slots);
}
const calendarId = getCalendarIdFromBag(relativeTo);
return {
...((refineTimeZoneString, getTimeZoneOps, calendarOps, bag) => {
const fields = refineCalendarFields(calendarOps, bag, dateFieldNamesAlpha, [], timeAndZoneFieldNames);
if (void 0 !== fields.timeZone) {
const isoDateFields = calendarOps.dateFromFields(fields), isoTimeFields = refineTimeBag(fields), timeZoneId = refineTimeZoneString(fields.timeZone);
return {
epochNanoseconds: getMatchingInstantFor(getTimeZoneOps(timeZoneId), {
...isoDateFields,
...isoTimeFields
}, void 0 !== fields.offset ? parseOffsetNano(fields.offset) : void 0),
timeZone: timeZoneId
};
}
return {
...calendarOps.dateFromFields(fields),
...isoTimeFieldDefaults
};
})(refineTimeZoneArg, queryNativeTimeZone, createNativeStandardOps(calendarId), relativeTo),
calendar: calendarId
};
}
return (s => {
const organized = parseDateTimeLike(requireString(s));
if (!organized) {
throw new RangeError(failedParse(s));
}
if (organized.timeZone) {
return finalizeZonedDateTime(organized, organized.offset ? parseOffsetNano(organized.offset) : void 0);
}
if (organized.hasZ) {
throw new RangeError(failedParse(s));
}
return finalizeDate(organized);
})(relativeTo);
}
}
function createOptionsTransformer(standardNames, fallbacks, exclusions) {
const excludedNameSet = new Set(exclusions);
return (options, strictOptions) => {
const hasAnyExclusions = exclusions && hasAnyPropsByName(options, exclusions);
if (!hasAnyPropsByName(options = ((propNames, props) => {
const filteredProps = {};
for (const propName in props) {
propNames.has(propName) || (filteredProps[propName] = props[propName]);
}
return filteredProps;
})(excludedNameSet, options), standardNames)) {
if (strictOptions && hasAnyExclusions) {
throw new TypeError("Invalid formatting options");
}
options = {
...fallbacks,
...options
};
}
return exclusions && (options.timeZone = utcTimeZoneId, [ "full", "long" ].includes(options.timeStyle) && (options.timeStyle = "medium")),
options;
};
}
function createFormatPrepper(config, queryFormat = createFormatForPrep, strictOptions = 0) {
const [transformOptions, , , getForcedTimeZoneId] = config;
return (locales, options = emptyOptions, ...slotsList) => {
const subformat = queryFormat(getForcedTimeZoneId && getForcedTimeZoneId(...slotsList), locales, options, transformOptions, strictOptions), resolvedOptions = subformat.resolvedOptions();
return [ subformat, ...toEpochMillis(config, resolvedOptions, slotsList) ];
};
}
function createFormatForPrep(forcedTimeZoneId, locales, options, transformOptions, strictOptions) {
if (options = transformOptions(options, strictOptions), forcedTimeZoneId) {
if (void 0 !== options.timeZone) {
throw new TypeError(forbiddenFormatTimeZone);
}
options.timeZone = forcedTimeZoneId;
}
return new RawDateTimeFormat(locales, options);
}
function toEpochMillis(config, resolvedOptions, slotsList) {
const [, slotsToEpochMilli, strictCalendarCheck] = config;
return slotsList.map((slots => (slots.calendar && ((internalCalendarId, resolvedCalendarId, strictCalendarCheck) => {
if ((strictCalendarCheck || internalCalendarId !== isoCalendarId) && internalCalendarId !== resolvedCalendarId) {
throw new RangeError(mismatchingCalendars);
}
})(slots.calendar, resolvedOptions.calendar, strictCalendarCheck), slotsToEpochMilli(slots, resolvedOptions))));
}
function slotsWithCalendarId(slots, calendarId) {
return {
...slots,
calendar: calendarId
};
}
function toPlainTimeSlots(arg, options) {
if (isObjectLike(arg)) {
const slots = getSlots(arg) || {};
switch (slots.branding) {
case PlainTimeBranding:
return refineOverflowOptions(options), slots;
case PlainDateTimeBranding:
return refineOverflowOptions(options), createPlainTimeSlots(slots);
case ZonedDateTimeBranding:
return refineOverflowOptions(options), zonedDateTimeToPlainTime(queryNativeTimeZone, slots);
}
return ((bag, options) => createPlainTimeSlots(refineTimeBag(refineFields(bag, timeFieldNamesAlpha, [], 1), refineOverflowOptions(options))))(arg, options);
}
const timeSlots = (s => {
let altParsed, organized = (s => {
const parts = timeRegExp.exec(s);
return parts ? (organizeAnnotationParts(parts[10]), organizeTimeParts(parts)) : void 0;
})(requireString(s));
if (!organized) {
if (organized = parseDateTimeLike(s), !organized) {
throw new RangeError(failedParse(s));
}
if (!organized.hasTime) {
throw new RangeError(failedParse(s));
}
if (organized.hasZ) {
throw new RangeError(invalidSubstring("Z"));
}
requireIsoCalendar(organized);
}
if ((altParsed = parseYearMonthOnly(s)) && isIsoDateFieldsValid(altParsed)) {
throw new RangeError(failedParse(s));
}
if ((altParsed = parseMonthDayOnly(s)) && isIsoDateFieldsValid(altParsed)) {
throw new RangeError(failedParse(s));
}
return createPlainTimeSlots(constrainIsoTimeFields(organized, 1));
})(arg);
return refineOverflowOptions(options), timeSlots;
}
function optionalToPlainTimeFields(timeArg) {
return void 0 === timeArg ? void 0 : toPlainTimeSlots(timeArg);
}
function toPlainDateTimeSlots(arg, options) {
if (isObjectLike(arg)) {
const slots = getSlots(arg) || {};
switch (slots.branding) {
case PlainDateTimeBranding:
return refineOverflowOptions(options), slots;
case PlainDateBranding:
return refineOverflowOptions(options), createPlainDateTimeSlots({
...slots,
...isoTimeFieldDefaults
});
case ZonedDateTimeBranding:
return refineOverflowOptions(options), zonedDateTimeToPlainDateTime(queryNativeTimeZone, slots);
}
return ((calendarOps, bag, options) => {
const fields = refineCalendarFields(calendarOps, bag, dateFieldNamesAlpha, [], timeFieldNamesAsc), overflow = refineOverflowOptions(options);
return createPlainDateTimeSlots(checkIsoDateTimeInBounds({
...calendarOps.dateFromFields(fields, fabricateOverflowOptions(overflow)),
...refineTimeBag(fields, overflow)
}));
})(createNativeStandardOps(getCalendarIdFromBag(arg)), arg, options);
}
const res = (s => {
const organized = parseDateTimeLike(requireString(s));
if (!organized || organized.hasZ) {
throw new RangeError(failedParse(s));
}
return createPlainDateTimeSlots(finalizeDateTime(organized));
})(arg);
return refineOverflowOptions(options), res;
}
function toPlainMonthDaySlots(arg, options) {
if (isObjectLike(arg)) {
const slots = getSlots(arg);
if (slots && slots.branding === PlainMonthDayBranding) {
return refineOverflowOptions(options), slots;
}
const calendarIdMaybe = extractCalendarIdFromBag(arg);
return ((calendarOps, calendarAbsent, bag, options) => {
const fields = refineCalendarFields(calendarOps, bag, dateFieldNamesAlpha, dayFieldNames);
return calendarAbsent && void 0 !== fields.month && void 0 === fields.monthCode && void 0 === fields.year && (fields.year = isoEpochFirstLeapYear),
calendarOps.monthDayFromFields(fields, options);
})(createNativeStandardOps(calendarIdMaybe || isoCalendarId), !calendarIdMaybe, arg, options);
}
const res = ((getCalendarOps, s) => {
const organized = parseMonthDayOnly(requireString(s));
if (organized) {
return requireIsoCalendar(organized), createPlainMonthDaySlots(checkIsoDateFields(organized));
}
const dateSlots = parsePlainDate(s, 0, 1), {calendar: calendar} = dateSlots, calendarOps = getCalendarOps(calendar), [origYear, origMonth, day] = calendarOps.dateParts(dateSlots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(origYear, origMonth), [year, month] = calendarOps.yearMonthForMonthDay(monthCodeNumber, isLeapMonth, day);
return createPlainMonthDaySlots(checkIsoDateInBounds(calendarOps.isoFields(year, month, day)), calendar);
})(createNativeStandardOps, arg);
return refineOverflowOptions(options), res;
}
function toPlainYearMonthSlots(arg, options) {
if (isObjectLike(arg)) {
const slots = getSlots(arg);
return slots && slots.branding === PlainYearMonthBranding ? (refineOverflowOptions(options),
slots) : ((calendarOps, bag, options) => {
const fields = refineCalendarFields(calendarOps, bag, yearMonthFieldNames, void 0);
return calendarOps.yearMonthFromFields(fields, options);
})(createNativeStandardOps(getCalendarIdFromBag(arg)), arg, options);
}
const res = ((getCalendarOps, s) => {
const organized = parseYearMonthOnly(requireString(s));
if (organized) {
return requireIsoCalendar(organized), createPlainYearMonthSlots(checkIsoYearMonthInBounds(checkIsoDateFields(organized)));
}
const isoSlots = parsePlainDate(s, 1);
return createPlainYearMonthSlots(moveToDayOfMonthUnsafe(getCalendarOps(isoSlots.calendar), isoSlots));
})(createNativeStandardOps, arg);
return refineOverflowOptions(options), res;
}
function toPlainDateSlots(arg, options) {
if (isObjectLike(arg)) {
const slots = getSlots(arg) || {};
switch (slots.branding) {
case PlainDateBranding:
return refineOverflowOptions(options), slots;
case PlainDateTimeBranding:
return refineOverflowOptions(options), createPlainDateSlots(slots);
case ZonedDateTimeBranding:
return refineOverflowOptions(options), zonedDateTimeToPlainDate(queryNativeTimeZone, slots);
}
return ((calendarOps, bag, options, requireFields = []) => {
const fields = refineCalendarFields(calendarOps, bag, dateFieldNamesAlpha, requireFields);
return calendarOps.dateFromFields(fields, options);
})(createNativeStandardOps(getCalendarIdFromBag(arg)), arg, options);
}
const res = parsePlainDate(arg);
return refineOverflowOptions(options), res;
}
function toZonedDateTimeSlots(arg, options) {
if (isObjectLike(arg)) {
const slots = getSlots(arg);
if (slots && slots.branding === ZonedDateTimeBranding) {
return refineZonedFieldOptions(options), slots;
}
const calendarId = getCalendarIdFromBag(arg);
return ((refineTimeZoneString, getTimeZoneOps, calendarOps, calendarId, bag, options) => {
const fields = refineCalendarFields(calendarOps, bag, dateFieldNamesAlpha, timeZoneFieldNames, timeAndZoneFieldNames), timeZoneId = refineTimeZoneString(fields.timeZone), [overflow, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options), isoDateFields = calendarOps.dateFromFields(fields, fabricateOverflowOptions(overflow)), isoTimeFields = refineTimeBag(fields, overflow);
return createZonedDateTimeSlots(getMatchingInstantFor(getTimeZoneOps(timeZoneId), {
...isoDateFields,
...isoTimeFields
}, void 0 !== fields.offset ? parseOffsetNano(fields.offset) : void 0, offsetDisambig, epochDisambig), timeZoneId, calendarId);
})(refineTimeZoneArg, queryNativeTimeZone, createNativeStandardOps(calendarId), calendarId, arg, options);
}
return ((s, options) => {
const organized = parseDateTimeLike(requireString(s));
if (!organized || !organized.timeZone) {
throw new RangeError(failedParse(s));
}
const {offset: offset} = organized, offsetNano = offset ? parseOffsetNano(offset) : void 0, [, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options);
return finalizeZonedDateTime(organized, offsetNano, offsetDisambig, epochDisambig);
})(arg, options);
}
function adaptDateMethods(methods) {
return mapProps((method => slots => method(slotsToIso(slots))), methods);
}
function slotsToIso(slots) {
return zonedEpochSlotsToIso(slots, queryNativeTimeZone);
}
function toInstantSlots(arg) {
if (isObjectLike(arg)) {
const slots = getSlots(arg);
if (slots) {
switch (slots.branding) {
case InstantBranding:
return slots;
case ZonedDateTimeBranding:
return createInstantSlots(slots.epochNanoseconds);
}
}
}
return (s => {
const organized = parseDateTimeLike(s = toStringViaPrimitive(s));
if (!organized) {
throw new RangeError(failedParse(s));
}
let offsetNano;
if (organized.hasZ) {
offsetNano = 0;
} else {
if (!organized.offset) {
throw new RangeError(failedParse(s));
}
offsetNano = parseOffsetNano(organized.offset);
}
return organized.timeZone && parseOffsetNanoMaybe(organized.timeZone, 1), createInstantSlots(isoToEpochNanoWithOffset(checkIsoDateTimeFields(organized), offsetNano));
})(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);
}), createNameDescriptors(methodName));
}
function createProxiedMethod(methodName) {
return Object.defineProperties((function(...args) {
return internalsMap.get(this).rawFormat[methodName](...args);
}), createNameDescriptors(methodName));
}
function createFormatPrepperForBranding(branding) {
const config = classFormatConfigs[branding];
if (!config) {
throw new TypeError(invalidFormatType(branding));
}
return createFormatPrepper(config, memoize(createFormatForPrep), 1);
}
function getCurrentIsoDateTime(timeZoneOps) {
const epochNano = getCurrentEpochNano();
return epochNanoToIso(epochNano, timeZoneOps.getOffsetNanosecondsFor(epochNano));
}
function getCurrentEpochNano() {
return numberToBigNano(Date.now(), nanoInMilli);
}
function getCurrentTimeZoneId() {
return currentTimeZoneId || (currentTimeZoneId = (new RawDateTimeFormat).resolvedOptions().timeZone);
}
const expectedInteger = (entityName, num) => `Non-integer ${entityName}: ${num}`, expectedPositive = (entityName, num) => `Non-positive ${entityName}: ${num}`, expectedFinite = (entityName, num) => `Non-finite ${entityName}: ${num}`, forbiddenBigIntToNumber = entityName => `Cannot convert bigint to ${entityName}`, invalidBigInt = arg => `Invalid bigint: ${arg}`, forbiddenSymbolToString = "Cannot convert Symbol to string", invalidObject = "Invalid object", numberOutOfRange = (entityName, val, min, max, choices) => choices ? numberOutOfRange(entityName, choices[val], choices[min], choices[max]) : invalidEntity(entityName, val) + `; must be between ${min}-${max}`, invalidEntity = (fieldName, val) => `Invalid ${fieldName}: ${val}`, missingField = fieldName => `Missing ${fieldName}`, forbiddenField = fieldName => `Invalid field ${fieldName}`, duplicateFields = fieldName => `Duplicate field ${fieldName}`, noValidFields = validFields => "No valid fields: " + validFields.join(), invalidChoice = (fieldName, val, choiceMap) => invalidEntity(fieldName, val) + "; must be " + Object.keys(choiceMap).join(), forbiddenEraParts = "Forbidden era/eraYear", mismatchingEraParts = "Mismatching era/eraYear", mismatchingYearAndEra = "Mismatching year/eraYear", invalidEra = era => `Invalid era: ${era}`, missingYear = allowEra => "Missing year" + (allowEra ? "/era/eraYear" : ""), invalidMonthCode = monthCode => `Invalid monthCode: ${monthCode}`, mismatchingMonthAndCode = "Mismatching month/monthCode", missingMonth = "Missing month/monthCode", invalidLeapMonth = "Invalid leap month", invalidProtocolResults = "Invalid protocol results", invalidCalendar = calendarId => invalidEntity("Calendar", calendarId), mismatchingCalendars = "Mismatching Calendars", invalidTimeZone = calendarId => invalidEntity("TimeZone", calendarId), mismatchingTimeZones = "Mismatching TimeZones", forbiddenIcuTimeZone = "Forbidden ICU TimeZone", outOfBoundsOffset = "Out-of-bounds offset", outOfBoundsDstGap = "Out-of-bounds TimeZone gap", invalidOffsetForTimeZone = "Invalid TimeZone offset", ambigOffset = "Ambiguous offset", outOfBoundsDate = "Out-of-bounds date", outOfBoundsDuration = "Out-of-bounds duration", forbiddenDurationSigns = "Cannot mix duration signs", invalidLargeUnits = "Cannot use large units", flippedSmallestLargestUnit = "smallestUnit > largestUnit", failedParse = s => `Cannot parse: ${s}`, invalidSubstring = substring => `Invalid substring: ${substring}`, invalidFormatType = branding => `Cannot format ${branding}`, forbiddenFormatTimeZone = "Cannot specify TimeZone", mapPropNamesToIndex = bindArgs(mapPropNames, ((_propVal, i) => i)), mapPropNamesToConstant = bindArgs(mapPropNames, ((_propVal, _i, constant) => constant)), padNumber2 = bindArgs(padNumber, 2), unitNameMap = {
nanosecond: 0,
microsecond: 1,
millisecond: 2,
second: 3,
minute: 4,
hour: 5,
day: 6,
week: 7,
month: 8,
year: 9
}, unitNamesAsc = Object.keys(unitNameMap), milliInDay = 864e5, milliInSec = 1e3, nanoInMicro = 1e3, nanoInMilli = 1e6, nanoInSec = 1e9, nanoInMinute = 6e10, nanoInHour = 36e11, nanoInUtcDay = 864e11, unitNanoMap = [ 1, nanoInMicro, nanoInMilli, nanoInSec, nanoInMinute, nanoInHour, nanoInUtcDay ], requireString = bindArgs(requireType, "string"), requireBoolean = bindArgs(requireType, "boolean"), requireNumber = bindArgs(requireType, "number"), durationFieldNamesAsc = unitNamesAsc.map((unitName => unitName + "s")), durationFieldNamesAlpha = sortStrings(durationFieldNamesAsc), durationTimeFieldNamesAsc = durationFieldNamesAsc.slice(0, 6), durationDateFieldNamesAsc = durationFieldNamesAsc.slice(6), durationCalendarFieldNamesAsc = durationDateFieldNamesAsc.slice(1), durationFieldIndexes = mapPropNamesToIndex(durationFieldNamesAsc), durationFieldDefaults = mapPropNamesToConstant(durationFieldNamesAsc, 0), durationTimeFieldDefaults = mapPropNamesToConstant(durationTimeFieldNamesAsc, 0), clearDurationFields = bindArgs(zeroOutProps, durationFieldNamesAsc), timeFieldNamesAsc = unitNamesAsc.slice(0, 6), timeFieldNamesAlpha = sortStrings(timeFieldNamesAsc), timeZoneFieldNames = [ "timeZone" ], timeAndOffsetFieldNames = [ ...timeFieldNamesAsc, "offset" ], timeAndZoneFieldNames = [ ...timeAndOffsetFieldNames, ...timeZoneFieldNames ], eraYearFieldNames = [ "era", "eraYear" ], allYearFieldNames = [ ...eraYearFieldNames, "year" ], yearFieldNames = [ "year" ], monthCodeFieldNames = [ "monthCode" ], monthFieldNames = [ "month", ...monthCodeFieldNames ], dayFieldNames = [ "day" ], yearMonthFieldNames = [ ...monthFieldNames, ...yearFieldNames ], yearMonthCodeFieldNames = [ ...monthCodeFieldNames, ...yearFieldNames ], dateFieldNamesAlpha = [ ...dayFieldNames, ...yearMonthFieldNames ], monthDayFieldNames = [ ...dayFieldNames, ...monthFieldNames ], monthCodeDayFieldNames = [ ...dayFieldNames, ...monthCodeFieldNames ], timeFieldDefaults = mapPropNamesToConstant(timeFieldNamesAsc, 0), isoCalendarId = "iso8601", gregoryCalendarId = "gregory", eraOriginsByCalendarId = {
[gregoryCalendarId]: {
"gregory-inverse": -1,
gregory: 0
},
japanese: {
"japanese-inverse": -1,
japanese: 0,
meiji: 1867,
taisho: 1911,
showa: 1925,
heisei: 1988,
reiwa: 2018
},
ethiopic: {
ethioaa: 0,
ethiopic: 5500
},
coptic: {
"coptic-inverse": -1,
coptic: 0
},
roc: {
"roc-inverse": -1,
roc: 0
},
buddhist: {
be: 0
},
islamic: {
ah: 0
},
indian: {
saka: 0
},
persian: {
ap: 0
}
}, eraRemapsByCalendarId = {
[gregoryCalendarId]: {
bce: "gregory-inverse",
ce: "gregory"
},
japanese: {
bce: "japanese-inverse",
ce: "japanese"
},
ethiopic: {
era0: "ethioaa",
era1: "ethiopic"
},
coptic: {
era0: "coptic-inverse",
era1: "coptic"
},
roc: {
broc: "roc-inverse",
minguo: "roc"
}
}, leapMonthMetas = {
chinese: 13,
dangi: 13,
hebrew: -6
}, isoTimeFieldNamesAsc = [ "isoNanosecond", "isoMicrosecond", "isoMillisecond", "isoSecond", "isoMinute", "isoHour" ], isoDateFieldNamesAsc = [ "isoDay", "isoMonth", "isoYear" ], isoDateTimeFieldNamesAsc = [ ...isoTimeFieldNamesAsc, ...isoDateFieldNamesAsc ], isoDateFieldNamesAlpha = sortStrings(isoDateFieldNamesAsc), isoTimeFieldNamesAlpha = sortStrings(isoTimeFieldNamesAsc), isoDateTimeFieldNamesAlpha = sortStrings(isoDateTimeFieldNamesAsc), isoTimeFieldDefaults = mapPropNamesToConstant(isoTimeFieldNamesAlpha, 0), clearIsoFields = bindArgs(zeroOutProps, isoDateTimeFieldNamesAsc), maxMilli = 1e8 * milliInDay, epochNanoMax = [ 1e8, 0 ], epochNanoMin = [ -1e8, 0 ], isoYearMax = 275760, isoYearMin = -271821, RawDateTimeFormat = Intl.DateTimeFormat, isoEpochOriginYear = 1970, isoEpochFirstLeapYear = 1972, isoMonthsInYear = 12, primaryJapaneseEraMilli = isoArgsToEpochMilli(1868, 9, 8), queryJapaneseEraParts = memoize((isoFields => {
const epochMilli = isoToEpochMilli(isoFields);
if (epochMilli < primaryJapaneseEraMilli) {
const {isoYear: isoYear} = isoFields;
return isoYear < 1 ? [ "japanese-inverse", 1 - isoYear ] : [ "japanese", isoYear ];
}
const intlParts = hashIntlFormatParts(queryCalendarIntlFormat("japanese"), epochMilli), {era: era, eraYear: eraYear} = parseIntlYear(intlParts, "japanese");
return [ era, eraYear ];
}), WeakMap), utcTimeZoneId = "UTC", periodDur = 5184e3, minPossibleTransition = isoArgsToEpochSec(1847), maxPossibleTransition = isoArgsToEpochSec((new Date).getUTCFullYear() + 10), queryIntlCalendar = memoize((calendarId => {
function epochMilliToIntlFields(epochMilli) {
return ((intlParts, calendarIdBase) => ({
...parseIntlYear(intlParts, calendarIdBase),
monthString: intlParts.month,
day: parseInt(intlParts.day)
}))(hashIntlFormatParts(intlFormat, epochMilli), calendarIdBase);
}
const intlFormat = queryCalendarIntlFormat(calendarId), calendarIdBase = computeCalendarIdBase(calendarId);
return {
id: calendarId,
queryFields: createIntlFieldCache(epochMilliToIntlFields),
queryYearData: createIntlYearDataCache(epochMilliToIntlFields)
};
})), queryCalendarIntlFormat = memoize((id => new RawDateTimeFormat("en-GB", {
calendar: id,
timeZone: utcTimeZoneId,
era: "short",
year: "numeric",
month: "short",
day: "numeric"
}))), monthCodeRegExp = /^M(\d{2})(L?)$/, smallestUnitStr = "smallestUnit", roundingIncName = "roundingIncrement", subsecDigitsName = "fractionalSecondDigits", overflowMap = {
constrain: 0,
reject: 1
}, overflowMapNames = Object.keys(overflowMap), directionMap = {
previous: -1,
next: 1
}, refineSmallestUnit = bindArgs(refineUnitOption, smallestUnitStr), refineLargestUnit = bindArgs(refineUnitOption, "largestUnit"), refineTotalUnit = bindArgs(refineUnitOption, "unit"), refineOverflow = bindArgs(refineChoiceOption, "overflow", overflowMap), refineEpochDisambig = bindArgs(refineChoiceOption, "disambiguation", {
compatible: 0,
reject: 1,
earlier: 2,
later: 3
}), refineOffsetDisambig = bindArgs(refineChoiceOption, "offset", {
reject: 0,
use: 1,
prefer: 2,
ignore: 3
}), refineCalendarDisplay = bindArgs(refineChoiceOption, "calendarName", {
auto: 0,
never: 1,
critical: 2,
always: 3
}), refineTimeZoneDisplay = bindArgs(refineChoiceOption, "timeZoneName", {
auto: 0,
never: 1,
critical: 2
}), refineOffsetDisplay = bindArgs(refineChoiceOption, "offset", {
auto: 0,
never: 1
}), refineRoundingMode = bindArgs(refineChoiceOption, "roundingMode", {
floor: 0,
halfFloor: 1,
ceil: 2,
halfCeil: 3,
trunc: 4,
halfTrunc: 5,
expand: 6,
halfExpand: 7,
halfEven: 8
}), PlainYearMonthBranding = "PlainYearMonth", PlainMonthDayBranding = "PlainMonthDay", PlainDateBranding = "PlainDate", PlainDateTimeBranding = "PlainDateTime", PlainTimeBranding = "PlainTime", ZonedDateTimeBranding = "ZonedDateTime", InstantBranding = "Instant", DurationBranding = "Duration", roundingModeFuncs = [ Math.floor, num => hasHalf(num) ? Math.floor(num) : Math.round(num), Math.ceil, num => hasHalf(num) ? Math.ceil(num) : Math.round(num), Math.trunc, num => hasHalf(num) ? Math.trunc(num) || 0 : Math.round(num), num => num < 0 ? Math.floor(num) : Math.ceil(num), num => Math.sign(num) * Math.round(Math.abs(num)) || 0, num => hasHalf(num) ? (num = Math.trunc(num) || 0) + num % 2 : Math.round(num) ], trailingZerosRE = /0+$/, zonedEpochSlotsToIso = memoize(((slots, getTimeZoneOps) => {
const {epochNanoseconds: epochNanoseconds} = slots, offsetNanoseconds = (getTimeZoneOps.getOffsetNanosecondsFor ? getTimeZoneOps : getTimeZoneOps(slots.timeZone)).getOffsetNanosecondsFor(epochNanoseconds), isoDateTimeFields = epochNanoToIso(epochNanoseconds, offsetNanoseconds);
return {
calendar: slots.calendar,
...isoDateTimeFields,
offsetNanoseconds: offsetNanoseconds
};
}), WeakMap), maxCalendarUnit = 2 ** 32 - 1, queryNativeTimeZone = memoize((timeZoneId => {
const essence = getTimeZoneEssence(timeZoneId);
return "object" == typeof essence ? new IntlTimeZone(essence) : new FixedTimeZone(essence || 0);
}));
class FixedTimeZone {
constructor(offsetNano) {
this.offsetNano = offsetNano;
}
getOffsetNanosecondsFor() {
return this.offsetNano;
}
getPossibleInstantsFor(isoDateTimeFields) {
return (isoFields => {
const bigNano = isoToEpochNano({
...isoFields,
...isoTimeFieldDefaults
});
if (!bigNano || Math.abs(bigNano[0]) > 1e8) {
throw new RangeError(outOfBoundsDate);
}
})(isoDateTimeFields), [ isoToEpochNanoWithOffset(isoDateTimeFields, this.offsetNano) ];
}
getTransition() {}
}
class IntlTimeZone {
constructor(format) {
this.tzStore = (computeOffsetSec => {
function getOffsetSec(epochSec) {
const clampedEpochSec = clampNumber(epochSec, minTransition, maxTransition), [startEpochSec, endEpochSec] = computePeriod(clampedEpochSec), startOffsetSec = getSample(startEpochSec), endOffsetSec = getSample(endEpochSec);
return startOffsetSec === endOffsetSec ? startOffsetSec : pinch(getSplit(startEpochSec, endEpochSec), startOffsetSec, endOffsetSec, epochSec);
}
function pinch(split, startOffsetSec, endOffsetSec, forEpochSec) {
let offsetSec, splitDurSec;
for (;(void 0 === forEpochSec || void 0 === (offsetSec = forEpochSec < split[0] ? startOffsetSec : forEpochSec >= split[1] ? endOffsetSec : void 0)) && (splitDurSec = split[1] - split[0]); ) {
const middleEpochSec = split[0] + Math.floor(splitDurSec / 2);
computeOffsetSec(middleEpochSec) === endOffsetSec ? split[1] = middleEpochSec : split[0] = middleEpochSec + 1;
}
return offsetSec;
}
const getSample = memoize(computeOffsetSec), getSplit = memoize(createSplitTuple);
let minTransition = minPossibleTransition, maxTransition = maxPossibleTransition;
return {
getPossibleEpochSec(zonedEpochSec) {
const wideOffsetSec0 = getOffsetSec(zonedEpochSec - 86400), wideOffsetSec1 = getOffsetSec(zonedEpochSec + 86400), wideUtcEpochSec0 = zonedEpochSec - wideOffsetSec0, wideUtcEpochSec1 = zonedEpochSec - wideOffsetSec1;
if (wideOffsetSec0 === wideOffsetSec1) {
return [ wideUtcEpochSec0 ];
}
const narrowOffsetSec0 = getOffsetSec(wideUtcEpochSec0);
return narrowOffsetSec0 === getOffsetSec(wideUtcEpochSec1) ? [ zonedEpochSec - narrowOffsetSec0 ] : wideOffsetSec0 > wideOffsetSec1 ? [ wideUtcEpochSec0, wideUtcEpochSec1 ] : [];
},
getOffsetSec: getOffsetSec,
getTransition(epochSec, direction) {
const clampedEpochSec = clampNumber(epochSec, minTransition, maxTransition);
let [startEpochSec, endEpochSec] = computePeriod(clampedEpochSec);
const inc = periodDur * direction, inBounds = direction < 0 ? () => endEpochSec > minTransition || (minTransition = clampedEpochSec,
0) : () => startEpochSec < maxTransition || (maxTransition = clampedEpochSec, 0);
for (;inBounds(); ) {
const startOffsetSec = getSample(startEpochSec), endOffsetSec = getSample(endEpochSec);
if (startOffsetSec !== endOffsetSec) {
const split = getSplit(startEpochSec, endEpochSec);
pinch(split, startOffsetSec, endOffsetSec);
const transitionEpochSec = split[0];
if ((compareNumbers(transitionEpochSec, epochSec) || 1) === direction) {
return transitionEpochSec;
}
}
startEpochSec += inc, endEpochSec += inc;
}
}
};
})((format => epochSec => {
const intlParts = hashIntlFormatParts(format, epochSec * milliInSec);
return isoArgsToEpochSec(parseIntlPartsYear(intlParts), parseInt(intlParts.month), parseInt(intlParts.day), parseInt(intlParts.hour), parseInt(intlParts.minute), parseInt(intlParts.second)) - epochSec;
})(format));
}
getOffsetNanosecondsFor(epochNano) {
return this.tzStore.getOffsetSec((epochNano => epochNanoToSecMod(epochNano)[0])(epochNano)) * nanoInSec;
}
getPossibleInstantsFor(isoFields) {
const [zonedEpochSec, subsecNano] = [ isoArgsToEpochSec((isoDateTimeFields = isoFields).isoYear, isoDateTimeFields.isoMonth, isoDateTimeFields.isoDay, isoDateTimeFields.isoHour, isoDateTimeFields.isoMinute, isoDateTimeFields.isoSecond), isoDateTimeFields.isoMillisecond * nanoInMilli + isoDateTimeFields.isoMicrosecond * nanoInMicro + isoDateTimeFields.isoNanosecond ];
var isoDateTimeFields;
return this.tzStore.getPossibleEpochSec(zonedEpochSec).map((epochSec => checkEpochNanoInBounds(moveBigNano(numberToBigNano(epochSec, nanoInSec), subsecNano))));
}
getTransition(epochNano, direction) {
const [epochSec, subsecNano] = epochNanoToSecMod(epochNano), resEpochSec = this.tzStore.getTransition(epochSec + (direction > 0 || subsecNano ? 1 : 0), direction);
if (void 0 !== resEpochSec) {
return numberToBigNano(resEpochSec, nanoInSec);
}
}
}
const timeRegExpStr = "(\\d{2})(?::?(\\d{2})(?::?(\\d{2})(?:[.,](\\d{1,9}))?)?)?", offsetRegExpStr = "([+-])" + timeRegExpStr, dateTimeRegExpStr = "(?:(?:([+-])(\\d{6}))|(\\d{4}))-?(\\d{2})-?(\\d{2})(?:[T ]" + timeRegExpStr + "(Z|" + offsetRegExpStr + ")?)?", yearMonthRegExp = createRegExp("(?:(?:([+-])(\\d{6}))|(\\d{4}))-?(\\d{2})((?:\\[(!?)([^\\]]*)\\]){0,9})"), monthDayRegExp = createRegExp("(?:--)?(\\d{2})-?(\\d{2})((?:\\[(!?)([^\\]]*)\\]){0,9})"), dateTimeRegExp = createRegExp(dateTimeRegExpStr + "((?:\\[(!?)([^\\]]*)\\]){0,9})"), timeRegExp = createRegExp("T?" + timeRegExpStr + "(?:" + offsetRegExpStr + ")?((?:\\[(!?)([^\\]]*)\\]){0,9})"), offsetRegExp = createRegExp(offsetRegExpStr), annotationRegExp = new RegExp("\\[(!?)([^\\]]*)\\]", "g"), durationRegExp = createRegExp("([+-])?P(\\d+Y)?(\\d+M)?(\\d+W)?(\\d+D)?(?:T(?:(\\d+)(?:[.,](\\d{1,9}))?H)?(?:(\\d+)(?:[.,](\\d{1,9}))?M)?(?:(\\d+)(?:[.,](\\d{1,9}))?S)?)?"), queryTimeZoneIntlFormat = memoize((id => new RawDateTimeFormat("en-GB", {
timeZone: id,
era: "short",
year: "numeric",
month: "numeric",
day: "numeric",
hour: "numeric",
minute: "numeric",
second: "numeric"
}))), icuRegExp = /^(AC|AE|AG|AR|AS|BE|BS|CA|CN|CS|CT|EA|EC|IE|IS|JS|MI|NE|NS|PL|PN|PR|PS|SS|VS)T$/, badCharactersRegExp = /[^\w\/:+-]+/, nativeStandardBase = {
dateAdd(isoDateFields, durationFields, options) {
const overflow = refineOverflowOptions(options);
let epochMilli, {years: years, months: months, weeks: weeks, days: days} = durationFields;
if (days += durationFieldsToBigNano(durationFields, 5)[0], years || months) {
epochMilli = ((moveOps, isoDateFields, years, months, overflow) => {
let [year, month, day] = moveOps.dateParts(isoDateFields);
if (years) {
const [monthCodeNumber, isLeapMonth] = moveOps.monthCodeParts(year, month);
year += years, month = monthCodeNumberToMonth(monthCodeNumber, isLeapMonth, moveOps.leapMonth(year)),
month = clampEntity("month", month, 1, moveOps.monthsInYearPart(year), overflow);
}
return months && ([year, month] = moveOps.monthAdd(year, month, months)), day = clampEntity("day", day, 1, moveOps.daysInMonthParts(year, month), overflow),
moveOps.epochMilli(year, month, day);
})(this, isoDateFields, years, months, overflow);
} else {
if (!weeks && !days) {
return isoDateFields;
}
epochMilli = isoToEpochMilli(isoDateFields);
}
if (void 0 === epochMilli) {
throw new RangeError(outOfBoundsDate);
}
return epochMilli += (7 * weeks + days) * milliInDay, checkIsoDateInBounds(epochMilliToIso(epochMilli));
},
dateUntil(startIsoFields, endIsoFields, largestUnit) {
if (largestUnit <= 7) {
let weeks = 0, days = diffDays({
...startIsoFields,
...isoTimeFieldDefaults
}, {
...endIsoFields,
...isoTimeFieldDefaults
});
return 7 === largestUnit && ([weeks, days] = divModTrunc(days, 7)), {
...durationFieldDefaults,
weeks: weeks,
days: days
};
}
const yearMonthDayStart = this.dateParts(startIsoFields), yearMonthDayEnd = this.dateParts(endIsoFields);
let [years, months, days] = ((calendarNative, year0, month0, day0, year1, month1, day1) => {
let yearDiff = year1 - year0, monthDiff = month1 - month0, dayDiff = day1 - day0;
if (yearDiff || monthDiff) {
const sign = Math.sign(yearDiff || monthDiff);
let daysInMonth1 = calendarNative.daysInMonthParts(year1, month1), dayCorrect = 0;
if (Math.sign(dayDiff) === -sign) {
const origDaysInMonth1 = daysInMonth1;
[year1, month1] = calendarNative.monthAdd(year1, month1, -sign), yearDiff = year1 - year0,
monthDiff = month1 - month0, daysInMonth1 = calendarNative.daysInMonthParts(year1, month1),
dayCorrect = sign < 0 ? -origDaysInMonth1 : daysInMonth1;
}
if (dayDiff = day1 - Math.min(day0, daysInMonth1) + dayCorrect, yearDiff) {
const [monthCodeNumber0, isLeapYear0] = calendarNative.monthCodeParts(year0, month0), [monthCodeNumber1, isLeapYear1] = calendarNative.monthCodeParts(year1, month1);
if (monthDiff = monthCodeNumber1 - monthCodeNumber0 || Number(isLeapYear1) - Number(isLeapYear0),
Math.sign(monthDiff) === -sign) {
const monthCorrect = sign < 0 && -calendarNative.monthsInYearPart(year1);
yearDiff = (year1 -= sign) - year0, monthDiff = month1 - monthCodeNumberToMonth(monthCodeNumber0, isLeapYear0, calendarNative.leapMonth(year1)) + (monthCorrect || calendarNative.monthsInYearPart(year1));
}
}
}
return [ yearDiff, monthDiff, dayDiff ];
})(this, ...yearMonthDayStart, ...yearMonthDayEnd);
return 8 === largestUnit && (months += this.monthsInYearSpan(years, yearMonthDayStart[0]),
years = 0), {
...durationFieldDefaults,
years: years,
months: months,
days: days
};
},
dateFromFields(fields, options) {
const overflow = refineOverflowOptions(options), year = refineYear(this, fields), month = refineMonth(this, fields, year, overflow), day = refineDay(this, fields, month, year, overflow);
return createPlainDateSlots(checkIsoDateInBounds(this.isoFields(year, month, day)), this.id || isoCalendarId);
},
yearMonthFromFields(fields, options) {
const overflow = refineOverflowOptions(options), year = refineYear(this, fields), month = refineMonth(this, fields, year, overflow);
return createPlainYearMonthSlots(checkIsoYearMonthInBounds(this.isoFields(year, month, 1)), this.id || isoCalendarId);
},
monthDayFromFields(fields, options) {
const overflow = refineOverflowOptions(options);
let day, monthCodeNumber, isLeapMonth, yearMaybe = void 0 !== fields.eraYear || void 0 !== fields.year ? refineYear(this, fields) : void 0;
const isIso = !this.id;
if (void 0 === yearMaybe && isIso && (yearMaybe = isoEpochFirstLeapYear), void 0 !== yearMaybe) {
const month = refineMonth(this, fields, yearMaybe, overflow);
day = refineDay(this, fields, month, yearMaybe, overflow);
const leapMonth = this.leapMonth(yearMaybe);
monthCodeNumber = monthToMonthCodeNumber(month, leapMonth), isLeapMonth = month === leapMonth;
} else {
if (void 0 === fields.monthCode) {
throw new TypeError(missingMonth);
}
if ([monthCodeNumber, isLeapMonth] = parseMonthCode(fields.monthCode), this.id && this.id !== gregoryCalendarId && "japanese" !== this.id) {
if (this.id && "coptic" === computeCalendarIdBase(this.id) && 0 === overflow) {
const maxLengthOfMonthCodeInAnyYear = isLeapMonth || 13 !== monthCodeNumber ? 30 : 6;
day = fields.day, day = clampNumber(day, 1, maxLengthOfMonthCodeInAnyYear);
} else if (this.id && "chinese" === computeCalendarIdBase(this.id) && 0 === overflow) {
const maxLengthOfMonthCodeInAnyYear = !isLeapMonth || 1 !== monthCodeNumber && 9 !== monthCodeNumber && 10 !== monthCodeNumber && 11 !== monthCodeNumber && 12 !== monthCodeNumber ? 30 : 29;
day = fields.day, day = clampNumber(day, 1, maxLengthOfMonthCodeInAnyYear);
} else {
day = fields.day;
}
} else {
day = refineDay(this, fields, refineMonth(this, fields, isoEpochFirstLeapYear, overflow), isoEpochFirstLeapYear, overflow);
}
}
const res = this.yearMonthForMonthDay(monthCodeNumber, isLeapMonth, day);
if (!res) {
throw new RangeError("Cannot guess year");
}
const [finalYear, finalMonth] = res;
return createPlainMonthDaySlots(checkIsoDateInBounds(this.isoFields(finalYear, finalMonth, day)), this.id || isoCalendarId);
},
fields(fieldNames) {
return getCalendarEraOrigins(this) && fieldNames.includes("year") ? [ ...fieldNames, ...eraYearFieldNames ] : fieldNames;
},
mergeFields(baseFields, additionalFields) {
const merged = Object.assign(Object.create(null), baseFields);
return spliceFields(merged, additionalFields, monthFieldNames), getCalendarEraOrigins(this) && (spliceFields(merged, additionalFields, allYearFieldNames),
"japanese" === this.id && spliceFields(merged, additionalFields, monthDayFieldNames, eraYearFieldNames)),
merged;
},
inLeapYear(isoFields) {
const [year] = this.dateParts(isoFields);
return this.inLeapYearPart(year);
},
monthsInYear(isoFields) {
const [year] = this.dateParts(isoFields);
return this.monthsInYearPart(year);
},
daysInMonth(isoFields) {
const [year, month] = this.dateParts(isoFields);
return this.daysInMonthParts(year, month);
},
daysInYear(isoFields) {
const [year] = this.dateParts(isoFields);
return this.daysInYearPart(year);
},
dayOfYear: computeNativeDayOfYear,
era(isoFields) {
return this.eraParts(isoFields)[0];
},
eraYear(isoFields) {
return this.eraParts(isoFields)[1];
},
monthCode(isoFields) {
const [year, month] = this.dateParts(isoFields), [monthCodeNumber, isLeapMonth] = this.monthCodeParts(year, month);
return formatMonthCode(monthCodeNumber, isLeapMonth);
},
dayOfWeek: computeIsoDayOfWeek,
daysInWeek() {
return 7;
}
}, isoPartOps = {
dateParts: computeIsoDateParts,
eraParts: computeIsoEraParts,
monthCodeParts: computeIsoMonthCodeParts
}, isoWeekOps = {
dayOfYear: computeNativeDayOfYear,
dateParts: computeIsoDateParts,
epochMilli: isoArgsToEpochMilli,
weekOfYear: computeNativeWeekOfYear,
yearOfWeek: computeNativeYearOfWeek,
weekParts(isoDateFields) {
function computeWeekShift(yDayOfWeek) {
return (7 - yDayOfWeek < minDaysInWeek ? 7 : 0) - yDayOfWeek;
}
function computeWeeksInYear(delta) {
const daysInYear = computeIsoDaysInYear(yearOfWeek + delta), sign = delta || 1, y1WeekShift = computeWeekShift(modFloor(y0DayOfWeek + daysInYear * sign, 7));
return weeksInYear = (daysInYear + (y1WeekShift - y0WeekShift) * sign) / 7;
}
const minDaysInWeek = this.id ? 1 : 4, isoDayOfWeek = computeIsoDayOfWeek(isoDateFields), isoDayOfYear = this.dayOfYear(isoDateFields), dayOfWeek = modFloor(isoDayOfWeek - 1, 7), dayOfYear = isoDayOfYear - 1, y0DayOfWeek = modFloor(dayOfWeek - dayOfYear, 7), y0WeekShift = computeWeekShift(y0DayOfWeek);
let weeksInYear, weekOfYear = Math.floor((dayOfYear - y0WeekShift) / 7) + 1, yearOfWeek = isoDateFields.isoYear;
return weekOfYear ? weekOfYear > computeWeeksInYear(0) && (weekOfYear = 1, yearOfWeek++) : (weekOfYear = computeWeeksInYear(-1),
yearOfWeek--), [ weekOfYear, yearOfWeek, weeksInYear ];
}
}, isoStandardOps = {
...nativeStandardBase,
...isoWeekOps,
dateParts: computeIsoDateParts,
eraParts: computeIsoEraParts,
monthCodeParts: computeIsoMonthCodeParts,
yearMonthForMonthDay(monthCodeNumber, isLeapMonth) {
if (!isLeapMonth) {
return [ isoEpochFirstLeapYear, monthCodeNumber ];
}
},
inLeapYearPart: computeIsoInLeapYear,
leapMonth() {},
monthsInYearPart: computeIsoMonthsInYear,
monthsInYearSpan: yearDelta => yearDelta * isoMonthsInYear,
daysInMonthParts: computeIsoDaysInMonth,
daysInYearPart: computeIsoDaysInYear,
isoFields(year, month, day) {
return {
isoYear: year,
isoMonth: month,
isoDay: day
};
},
epochMilli: isoArgsToEpochMilli,
monthAdd(year, month, monthDelta) {
return year += divTrunc(monthDelta, isoMonthsInYear), (month += modTrunc(monthDelta, isoMonthsInYear)) < 1 ? (year--,
month += isoMonthsInYear) : month > isoMonthsInYear && (year++, month -= isoMonthsInYear),
[ year, month ];
},
year(isoFields) {
return isoFields.isoYear;
},
month(isoFields) {
return isoFields.isoMonth;
},
day: isoFields => isoFields.isoDay
}, intlPartOps = {
dateParts: computeIntlDateParts,
eraParts: computeIntlEraParts,
monthCodeParts: computeIntlMonthCodeParts
}, intlWeekOps = {
dayOfYear: computeNativeDayOfYear,
dateParts: computeIntlDateParts,
epochMilli: computeIntlEpochMilli,
weekOfYear: computeNativeWeekOfYear,
yearOfWeek: computeNativeYearOfWeek,
weekParts() {
return [];
}
}, intlStandardOps = {
...nativeStandardBase,
...intlWeekOps,
dateParts: computeIntlDateParts,
eraParts: computeIntlEraParts,
monthCodeParts: computeIntlMonthCodeParts,
yearMonthForMonthDay(monthCodeNumber, isLeapMonth, day) {
const startIsoYear = this.id && "chinese" === computeCalendarIdBase(this.id) ? ((monthCodeNumber, isLeapMonth, day) => {
if (isLeapMonth) {
switch (monthCodeNumber) {
case 1:
return 1651;
case 2:
return day < 30 ? 1947 : 1765;
case 3:
return day < 30 ? 1966 : 1955;
case 4:
return day < 30 ? 1963 : 1944;
case 5:
return day < 30 ? 1971 : 1952;
case 6:
return day < 30 ? 1960 : 1941;
case 7:
return day < 30 ? 1968 : 1938;
case 8:
return day < 30 ? 1957 : 1718;
case 9:
return 1832;
case 10:
return 1870;
case 11:
return 1814;
case 12:
return 1890;
}
}
return 1972;
})(monthCodeNumber, isLeapMonth, day) : isoEpochFirstLeapYear;
let [startYear, startMonth, startDay] = computeIntlDateParts.call(this, {
isoYear: startIsoYear,
isoMonth: isoMonthsInYear,
isoDay: 31
});
const startYearLeapMonth = computeIntlLeapMonth.call(this, startYear), startMonthIsLeap = startMonth === startYearLeapMonth;
1 === (compareNumbers(monthCodeNumber, monthToMonthCodeNumber(startMonth, startYearLeapMonth)) || compareNumbers(Number(isLeapMonth), Number(startMonthIsLeap)) || compareNumbers(day, startDay)) && startYear--;
for (let yearMove = 0; yearMove < 100; yearMove++) {
const tryYear = startYear - yearMove, tryLeapMonth = computeIntlLeapMonth.call(this, tryYear), tryMonth = monthCodeNumberToMonth(monthCodeNumber, isLeapMonth, tryLeapMonth);
if (isLeapMonth === (tryMonth === tryLeapMonth) && day <= computeIntlDaysInMonth.call(this, tryYear, tryMonth)) {
return [ tryYear, tryMonth ];
}
}
},
inLeapYearPart(year) {
const days = computeIntlDaysInYear.call(this, year);
return days > computeIntlDaysInYear.call(this, year - 1) && days > computeIntlDaysInYear.call(this, year + 1);
},
leapMonth: computeIntlLeapMonth,
monthsInYearPart: computeIntlMonthsInYear,
monthsInYearSpan(yearDelta, yearStart) {
const yearEnd = yearStart + yearDelta, yearSign = Math.sign(yearDelta), yearCorrection = yearSign < 0 ? -1 : 0;
let months = 0;
for (let year = yearStart; year !== yearEnd; year += yearSign) {
months += computeIntlMonthsInYear.call(this, year + yearCorrection);
}
return months;
},
daysInMonthParts: computeIntlDaysInMonth,
daysInYearPart: computeIntlDaysInYear,
isoFields(year, month, day) {
return epochMilliToIso(computeIntlEpochMilli.call(this, year, month, day));
},
epochMilli: computeIntlEpochMilli,
monthAdd(year, month, monthDelta) {
if (monthDelta) {
if (month += monthDelta, !Number.isSafeInteger(month)) {
throw new RangeError(outOfBoundsDate);
}
if (monthDelta < 0) {
for (;month < 1; ) {
month += computeIntlMonthsInYear.call(this, --year);
}
} else {
let monthsInYear;
for (;month > (monthsInYear = computeIntlMonthsInYear.call(this, year)); ) {
month -= monthsInYear, year++;
}
}
}
return [ year, month ];
},
year(isoFields) {
return this.queryFields(isoFields).year;
},
month(isoFields) {
const {year: year, monthString: monthString} = this.queryFields(isoFields), {monthStringToIndex: monthStringToIndex} = this.queryYearData(year);
return monthStringToIndex[monthString] + 1;
},
day(isoFields) {
return this.queryFields(isoFields).day;
}
}, createNativePartOps = createNativeOpsCreator(isoPartOps, intlPartOps), createNativeStandardOps = createNativeOpsCreator(isoStandardOps, intlStandardOps), builtinRefiners = {
...{
era: toStringViaPrimitive,
eraYear: toInteger,
year: toInteger,
month: toPositiveInteger,
monthCode(monthCode) {
const s = toStringViaPrimitive(monthCode);
return parseMonthCode(s), s;
},
day: toPositiveInteger
},
...mapPropNamesToConstant(timeFieldNamesAsc, toInteger),
...mapPropNamesToConstant(durationFieldNamesAsc, toStrictInteger),
offset(offsetString) {
const s = toStringViaPrimitive(offsetString);
return parseOffsetNano(s), s;
}
}, timeFieldsToIso = bindArgs(remapProps, timeFieldNamesAsc, isoTimeFieldNamesAsc), isoTimeFieldsToCal = bindArgs(remapProps, isoTimeFieldNamesAsc, timeFieldNamesAsc), slotsMap = new WeakMap, getSlots = slotsMap.get.bind(slotsMap), setSlots = slotsMap.set.bind(slotsMap), yearMonthOnlyRefiners = {
era(input) {
if (void 0 !== input) {
return requireString(input);
}
},
eraYear: requireIntegerOrUndefined,
year: requireInteger,
month: requirePositiveInteger,
daysInMonth: requirePositiveInteger,
daysInYear: requirePositiveInteger,
inLeapYear: requireBoolean,
monthsInYear: requirePositiveInteger
}, monthOnlyRefiners = {
monthCode: requireString
}, dayOnlyRefiners = {
day: requirePositiveInteger
}, dateOnlyRefiners = {
dayOfWeek: requirePositiveInteger,
dayOfYear: requirePositiveInteger,
weekOfYear(input) {
if (void 0 !== input) {
return requirePositiveInteger(input);
}
},
yearOfWeek: requireIntegerOrUndefined,
daysInWeek: requirePositiveInteger
}, dateGetters = createCalendarGetters({
...yearMonthOnlyRefiners,
...monthOnlyRefiners,
...dayOnlyRefiners,
...dateOnlyRefiners
}), yearMonthGetters = createCalendarGetters({
...yearMonthOnlyRefiners,
...monthOnlyRefiners
}), monthDayGetters = createCalendarGetters({
...monthOnlyRefiners,
...dayOnlyRefiners
}), calendarIdGetters = {
calendarId: slots => slots.calendar
}, durationGetters = mapPropNames((propName => slots => slots[propName]), durationFieldNamesAsc.concat("sign")), timeGetters = mapPropNames(((_name, i) => slots => slots[isoTimeFieldNamesAsc[i]]), timeFieldNamesAsc), epochGetters = {
epochMilliseconds: getEpochMilli,
epochNanoseconds(slots) {
return ((bigNano, divisorNano = 1) => {
const [days, timeNano] = bigNano, whole = Math.floor(timeNano / divisorNano), wholeInDay = nanoInUtcDay / divisorNano;
return BigInt(days) * BigInt(wholeInDay) + BigInt(whole);
})(slots.epochNanoseconds);
}
}, [Duration, createDuration, getDurationSlots] = createSlotClass(DurationBranding, ((years = 0, months = 0, weeks = 0, days = 0, hours = 0, minutes = 0, seconds = 0, milliseconds = 0, microseconds = 0, nanoseconds = 0) => createDurationSlots(checkDurationUnits(mapProps(toStrictInteger, zipProps(durationFieldNamesAsc, [ years, months, weeks, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds ]))))), {
...durationGetters,
blank(slots) {
return !slots.sign;
}
}, {
with: (slots, mod) => createDuration(((slots, fields) => {
return createDurationSlots((initialFields = slots, modFields = fields, checkDurationUnits({
...initialFields,
...refineFields(modFields, durationFieldNamesAlpha)
})));
var initialFields, modFields;
})(slots, mod)),
negated: slots => createDuration(negateDuration(slots)),
abs: slots => createDuration((slots => -1 === slots.sign ? negateDuration(slots) : slots)(slots)),
add: (slots, otherArg, options) => createDuration(addDurations(refinePublicRelativeTo, createNativeStandardOps, queryNativeTimeZone, 0, slots, toDurationSlots(otherArg), options)),
subtract: (slots, otherArg, options) => createDuration(addDurations(refinePublicRelativeTo, createNativeStandardOps, queryNativeTimeZone, 1, slots, toDurationSlots(otherArg), options)),
round: (slots, options) => createDuration(((refineRelativeTo, getCalendarOps, getTimeZoneOps, slots, options) => {
const durationLargestUnit = getMaxDurationUnit(slots), [largestUnit, smallestUnit, roundingInc, roundingMode, relativeToSlots] = ((options, defaultLargestUnit, refineRelativeTo) => {
options = normalizeOptionsOrString(options, smallestUnitStr);
let largestUnit = refineLargestUnit(options);
const relativeToInternals = refineRelativeTo(options.relativeTo);
let roundingInc = parseRoundingIncInteger(options);
const roundingMode = refineRoundingMode(options, 7);
let smallestUnit = refineSmallestUnit(options);
if (void 0 === largestUnit && void 0 === smallestUnit) {
throw new RangeError("Required smallestUnit or largestUnit");
}
if (null == smallestUnit && (smallestUnit = 0), null == largestUnit && (largestUnit = Math.max(smallestUnit, defaultLargestUnit)),
checkLargestSmallestUnit(largestUnit, smallestUnit), roundingInc = refineRoundingInc(roundingInc, smallestUnit, 1),
roundingInc > 1 && smallestUnit > 5 && largestUnit !== smallestUnit) {
throw new RangeError("For calendar units with roundingIncrement > 1, use largestUnit = smallestUnit");
}
return [ largestUnit, smallestUnit, roundingInc, roundingMode, relativeToInternals ];
})(options, durationLargestUnit, refineRelativeTo), maxUnit = Math.max(durationLargestUnit, largestUnit);
if (!relativeToSlots && maxUnit <= 6) {
return createDurationSlots(checkDurationUnits(((durationFields, largestUnit, smallestUnit, roundingInc, roundingMode) => {
const roundedBigNano = roundBigNano(durationFieldsToBigNano(durationFields), smallestUnit, roundingInc, roundingMode);
return {
...durationFieldDefaults,
...nanoToDurationDayTimeFields(roundedBigNano, largestUnit)
};
})(slots, largestUnit, smallestUnit, roundingInc, roundingMode)));
}
if (!isZonedEpochSlots(relativeToSlots) && !slots.sign) {
return slots;
}
if (!relativeToSlots) {
throw new RangeError("Missing relativeTo");
}
const [marker, calendarOps, timeZoneOps] = createMarkerSystem(getCalendarOps, getTimeZoneOps, relativeToSlots), markerToEpochNano = createMarkerToEpochNano(timeZoneOps), moveMarker = createMoveMarker(timeZoneOps), diffMarkers = createDiffMarkers(timeZoneOps), endMarker = moveMarker(calendarOps, marker, slots);
isZonedEpochSlots(relativeToSlots) || (checkIsoDateTimeInBounds(marker), checkIsoDateTimeInBounds(endMarker));
let balancedDuration = diffMarkers(calendarOps, marker, endMarker, largestUnit);
const origSign = slots.sign, balancedSign = computeDurationSign(balancedDuration);
if (origSign && balancedSign && origSign !== balancedSign) {
throw new RangeError(invalidProtocolResults);
}
return balancedDuration = roundRelativeDuration(balancedDuration, markerToEpochNano(endMarker), largestUnit, smallestUnit, roundingInc, roundingMode, calendarOps, marker, markerToEpochNano, moveMarker),
createDurationSlots(balancedDuration);
})(refinePublicRelativeTo, createNativeStandardOps, queryNativeTimeZone, slots, options)),
total: (slots, options) => ((refineRelativeTo, getCalendarOps, getTimeZoneOps, slots, options) => {
const maxDurationUnit = getMaxDurationUnit(slots), [totalUnit, relativeToSlots] = ((options, refineRelativeTo) => {
const relativeToInternals = refineRelativeTo((options = normalizeOptionsOrString(options, "unit")).relativeTo);
let totalUnit = refineTotalUnit(options);
return totalUnit = requirePropDefined("unit", totalUnit), [ totalUnit, relativeToInternals ];
})(options, refineRelativeTo), maxUnit = Math.max(totalUnit, maxDurationUnit);
if (!relativeToSlots && isUniformUnit(maxUnit, relativeToSlots)) {
return totalDayTimeDuration(slots, totalUnit);
}
if (!relativeToSlots) {
throw new RangeError("Missing relativeTo");
}
if (!slots.sign) {
return 0;
}
const [marker, calendarOps, timeZoneOps] = createMarkerSystem(getCalendarOps, getTimeZoneOps, relativeToSlots), markerToEpochNano = createMarkerToEpochNano(timeZoneOps), moveMarker = createMoveMarker(timeZoneOps), diffMarkers = createDiffMarkers(timeZoneOps), endMarker = moveMarker(calendarOps, marker, slots);
isZonedEpochSlots(relativeToSlots) || (checkIsoDateTimeInBounds(marker), checkIsoDateTimeInBounds(endMarker));
const balancedDuration = diffMarkers(calendarOps, marker, endMarker, totalUnit);
return isUniformUnit(totalUnit, relativeToSlots) ? totalDayTimeDuration(balancedDuration, totalUnit) : ((durationFields, endEpochNano, totalUnit, calendarOps, marker, markerToEpochNano, moveMarker) => {
const sign = computeDurationSign(durationFields), [epochNano0, epochNano1] = clampRelativeDuration(calendarOps, clearDurationFields(totalUnit, durationFields), totalUnit, sign, marker, markerToEpochNano, moveMarker), frac = computeEpochNanoFrac(endEpochNano, epochNano0, epochNano1);
return durationFields[durationFieldNamesAsc[totalUnit]] + frac * sign;
})(balancedDuration, markerToEpochNano(endMarker), totalUnit, calendarOps, marker, markerToEpochNano, moveMarker);
})(refinePublicRelativeTo, createNativeStandardOps, queryNativeTimeZone, slots, options),
toLocaleString(slots, locales, options) {
return Intl.DurationFormat ? new Intl.DurationFormat(locales, options).format(this) : formatDurationIso(slots);
},
toString: formatDurationIso,
toJSON: slots => formatDurationIso(slots),
valueOf: neverValueOf
}, {
from: arg => createDuration(toDurationSlots(arg)),
compare: (durationArg0, durationArg1, options) => ((refineRelativeTo, getCalendarOps, getTimeZoneOps, durationSlots0, durationSlots1, options) => {
const relativeToSlots = refineRelativeTo(normalizeOptions(options).relativeTo), maxUnit = Math.max(getMaxDurationUnit(durationSlots0), getMaxDurationUnit(durationSlots1));
if (allPropsEqual(durationFieldNamesAsc, durationSlots0, durationSlots1)) {
return 0;
}
if (isUniformUnit(maxUnit, relativeToSlots)) {
return compareBigNanos(durationFieldsToBigNano(durationSlots0), durationFieldsToBigNano(durationSlots1));
}
if (!relativeToSlots) {
throw new RangeError("Missing relativeTo");
}
const [marker, calendarOps, timeZoneOps] = createMarkerSystem(getCalendarOps, getTimeZoneOps, relativeToSlots), markerToEpochNano = createMarkerToEpochNano(timeZoneOps), moveMarker = createMoveMarker(timeZoneOps);
return compareBigNanos(markerToEpochNano(moveMarker(calendarOps, marker, durationSlots0)), markerToEpochNano(moveMarker(calendarOps, marker, durationSlots1)));
})(refinePublicRelativeTo, createNativeStandardOps, queryNativeTimeZone, toDurationSlots(durationArg0), toDurationSlots(durationArg1), options)
}), timeZoneNameStrs = [ "timeZoneName" ], monthDayFallbacks = {
month: "numeric",
day: "numeric"
}, yearMonthFallbacks = {
year: "numeric",
month: "numeric"
}, dateFallbacks = {
...yearMonthFallbacks,
day: "numeric"
}, timeFallbacks = {
hour: "numeric",
minute: "numeric",
second: "numeric"
}, dateTimeFallbacks = {
...dateFallbacks,
...timeFallbacks
}, zonedFallbacks = {
...dateTimeFallbacks,
timeZoneName: "short"
}, yearMonthFallbackNames = Object.keys(yearMonthFallbacks), monthDayFallbackNames = Object.keys(monthDayFallbacks), dateFallbackNames = Object.keys(dateFallbacks), timeFallbackNames = Object.keys(timeFallbacks), dateStyleNames = [ "dateStyle" ], yearMonthStandardNames = [ ...yearMonthFallbackNames, ...dateStyleNames ], monthDayStandardNames = [ ...monthDayFallbackNames, ...dateStyleNames ], dateStandardNames = [ ...dateFallbackNames, ...dateStyleNames, "weekday" ], timeStandardNames = [ ...timeFallbackNames, "dayPeriod", "timeStyle", "fractionalSecondDigits" ], dateTimeStandardNames = [ ...dateStandardNames, ...timeStandardNames ], dateExclusions = [ ...timeZoneNameStrs, ...timeStandardNames ], timeExclusions = [ ...timeZoneNameStrs, ...dateStandardNames ], yearMonthExclusions = [ ...timeZoneNameStrs, "day", "weekday", ...timeStandardNames ], monthDayExclusions = [ ...timeZoneNameStrs, "year", "weekday", ...timeStandardNames ], transformInstantOptions = createOptionsTransformer(dateTimeStandardNames, dateTimeFallbacks), transformZonedOptions = createOptionsTransformer(dateTimeStandardNames, zonedFallbacks), transformDateTimeOptions = createOptionsTransformer(dateTimeStandardNames, dateTimeFallbacks, timeZoneNameStrs), transformDateOptions = createOptionsTransformer(dateStandardNames, dateFallbacks, dateExclusions), transformTimeOptions = createOptionsTransformer(timeStandardNames, timeFallbacks, timeExclusions), transformYearMonthOptions = createOptionsTransformer(yearMonthStandardNames, yearMonthFallbacks, yearMonthExclusions), transformMonthDayOptions = createOptionsTransformer(monthDayStandardNames, monthDayFallbacks, monthDayExclusions), emptyOptions = {}, nonBuggyIsoResolve = new RawDateTimeFormat(void 0, {
calendar: isoCalendarId
}).resolvedOptions().calendar === isoCalendarId, instantConfig = [ transformInstantOptions, getEpochMilli ], zonedConfig = [ transformZonedOptions, getEpochMilli, 0, (slots0, slots1) => {
const timeZoneId = slots0.timeZone;
if (slots1 && slots1.timeZone !== timeZoneId) {
throw new RangeError(mismatchingTimeZones);
}
return timeZoneId;
} ], dateTimeConfig = [ transformDateTimeOptions, isoToEpochMilli ], dateConfig = [ transformDateOptions, isoToEpochMilli ], timeConfig = [ transformTimeOptions, isoFields => isoTimeFieldsToNano(isoFields) / nanoInMilli ], yearMonthConfig = [ transformYearMonthOptions, isoToEpochMilli, nonBuggyIsoResolve ], monthDayConfig = [ transformMonthDayOptions, isoToEpochMilli, nonBuggyIsoResolve ], classFormatConfigs = {
Instant: instantConfig,
PlainDateTime: dateTimeConfig,
PlainDate: dateConfig,
PlainTime: timeConfig,
PlainYearMonth: yearMonthConfig,
PlainMonthDay: monthDayConfig
}, prepInstantFormat = createFormatPrepper(instantConfig), prepZonedDateTimeFormat = createFormatPrepper(zonedConfig), prepPlainDateTimeFormat = createFormatPrepper(dateTimeConfig), prepPlainDateFormat = createFormatPrepper(dateConfig), prepPlainTimeFormat = createFormatPrepper(timeConfig), prepPlainYearMonthFormat = createFormatPrepper(yearMonthConfig), prepPlainMonthDayFormat = createFormatPrepper(monthDayConfig), [PlainTime, createPlainTime] = createSlotClass(PlainTimeBranding, ((isoHour = 0, isoMinute = 0, isoSecond = 0, isoMillisecond = 0, isoMicrosecond = 0, isoNanosecond = 0) => createPlainTimeSlots(constrainIsoTimeFields(mapProps(toInteger, zipProps(isoTimeFieldNamesAsc, [ isoHour, isoMinute, isoSecond, isoMillisecond, isoMicrosecond, isoNanosecond ])), 1))), timeGetters, {
with(_slots, mod, options) {
return createPlainTime(((initialFields, mod, options) => createPlainTimeSlots(((initialFields, modFields, options) => refineTimeBag({
...pluckProps(timeFieldNamesAlpha, initialFields),
...refineFields(modFields, timeFieldNamesAlpha)
}, refineOverflowOptions(options)))(initialFields, mod, options)))(this, rejectInvalidBag(mod), options));
},
add: (slots, durationArg) => createPlainTime(movePlainTime(0, slots, toDurationSlots(durationArg))),
subtract: (slots, durationArg) => createPlainTime(movePlainTime(1, slots, toDurationSlots(durationArg))),
until: (slots, otherArg, options) => createDuration(diffPlainTimes(0, slots, toPlainTimeSlots(otherArg), options)),
since: (slots, otherArg, options) => createDuration(diffPlainTimes(1, slots, toPlainTimeSlots(otherArg), options)),
round: (slots, options) => createPlainTime(((slots, options) => {
const [a, b, c] = refineRoundingOptions(options, 5);
var roundingMode;
return createPlainTimeSlots((roundingMode = c, roundTimeToNano(slots, computeNanoInc(a, b), roundingMode)[0]));
})(slots, options)),
equals(slots, other) {
return !compareIsoTimeFields(slots, toPlainTimeSlots(other));
},
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepPlainTimeFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: formatPlainTimeIso,
toJSON: slots => formatPlainTimeIso(slots),
valueOf: neverValueOf
}, {
from: (arg, options) => createPlainTime(toPlainTimeSlots(arg, options)),
compare: (arg0, arg1) => compareIsoTimeFields(toPlainTimeSlots(arg0), toPlainTimeSlots(arg1))
}), [PlainDateTime, createPlainDateTime] = createSlotClass(PlainDateTimeBranding, bindArgs(((refineCalendarArg, isoYear, isoMonth, isoDay, isoHour = 0, isoMinute = 0, isoSecond = 0, isoMillisecond = 0, isoMicrosecond = 0, isoNanosecond = 0, calendarArg = isoCalendarId) => createPlainDateTimeSlots(checkIsoDateTimeInBounds(checkIsoDateTimeFields(mapProps(toInteger, zipProps(isoDateTimeFieldNamesAsc, [ isoYear, isoMonth, isoDay, isoHour, isoMinute, isoSecond, isoMillisecond, isoMicrosecond, isoNanosecond ])))), refineCalendarArg(calendarArg))), refineCalendarId), {
...calendarIdGetters,
...dateGetters,
...timeGetters
}, {
with: (slots, mod, options) => createPlainDateTime(((getCalendarOps, plainDateTimeSlots, modFields, options) => {
const calendarOps = getCalendarOps(plainDateTimeSlots.calendar), validFieldNames = [ ...calendarOps.fields(dateFieldNamesAlpha), ...timeFieldNamesAsc ].sort(), origFields = {
...computeDateEssentials(slots = plainDateTimeSlots),
hour: slots.isoHour,
minute: slots.isoMinute,
second: slots.isoSecond,
millisecond: slots.isoMillisecond,
microsecond: slots.isoMicrosecond,
nanosecond: slots.isoNanosecond
};
var slots;
const partialFields = refineFields(modFields, validFieldNames), overflow = refineOverflowOptions(options), mergedCalendarFields = calendarOps.mergeFields(origFields, partialFields), mergedAllFields = {
...origFields,
...partialFields
};
return createPlainDateTimeSlots(checkIsoDateTimeInBounds({
...calendarOps.dateFromFields(mergedCalendarFields, fabricateOverflowOptions(overflow)),
...constrainIsoTimeFields(timeFieldsToIso(mergedAllFields), overflow)
}));
})(createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
withCalendar: (slots, calendarArg) => createPlainDateTime(slotsWithCalendarId(slots, refineCalendarArg(calendarArg))),
withPlainTime: (slots, plainTimeArg) => createPlainDateTime(((plainDateTimeSlots, plainTimeSlots = isoTimeFieldDefaults) => createPlainDateTimeSlots(checkIsoDateTimeInBounds({
...plainDateTimeSlots,
...plainTimeSlots
})))(slots, optionalToPlainTimeFields(plainTimeArg))),
add: (slots, durationArg, options) => createPlainDateTime(movePlainDateTime(createNativeStandardOps, 0, slots, toDurationSlots(durationArg), options)),
subtract: (slots, durationArg, options) => createPlainDateTime(movePlainDateTime(createNativeStandardOps, 1, slots, toDurationSlots(durationArg), options)),
until: (slots, otherArg, options) => createDuration(diffPlainDateTimes(createNativeStandardOps, 0, slots, toPlainDateTimeSlots(otherArg), options)),
since: (slots, otherArg, options) => createDuration(diffPlainDateTimes(createNativeStandardOps, 1, slots, toPlainDateTimeSlots(otherArg), options)),
round: (slots, options) => createPlainDateTime(((slots, options) => createPlainDateTimeSlots(roundDateTime(slots, ...refineRoundingOptions(options)), slots.calendar))(slots, options)),
equals(slots, otherArg) {
return !compareIsoDateTimeFields(plainDateTimeSlots0 = slots, plainDateTimeSlots1 = toPlainDateTimeSlots(otherArg)) && plainDateTimeSlots0.calendar === plainDateTimeSlots1.calendar;
var plainDateTimeSlots0, plainDateTimeSlots1;
},
toZonedDateTime: (slots, timeZoneArg, options) => createZonedDateTime(((getTimeZoneOps, plainDateTimeSlots, timeZoneId, options) => {
const epochNano = ((getTimeZoneOps, timeZoneId, isoFields, options) => {
const epochDisambig = (options => refineEpochDisambig(normalizeOptions(options)))(options);
return getSingleInstantFor(getTimeZoneOps(timeZoneId), isoFields, epochDisambig);
})(getTimeZoneOps, timeZoneId, plainDateTimeSlots, options);
return createZonedDateTimeSlots(checkEpochNanoInBounds(epochNano), timeZoneId, plainDateTimeSlots.calendar);
})(queryNativeTimeZone, slots, refineTimeZoneArg(timeZoneArg), options)),
toPlainDate: slots => createPlainDate(createPlainDateSlots(slots)),
toPlainTime: slots => createPlainTime(createPlainTimeSlots(slots)),
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepPlainDateTimeFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: formatPlainDateTimeIso,
toJSON: slots => formatPlainDateTimeIso(slots),
valueOf: neverValueOf
}, {
from: (arg, options) => createPlainDateTime(toPlainDateTimeSlots(arg, options)),
compare: (arg0, arg1) => compareIsoDateTimeFields(toPlainDateTimeSlots(arg0), toPlainDateTimeSlots(arg1))
}), [PlainMonthDay, createPlainMonthDay, getPlainMonthDaySlots] = createSlotClass(PlainMonthDayBranding, bindArgs(((refineCalendarArg, isoMonth, isoDay, calendarArg = isoCalendarId, referenceIsoYear = isoEpochFirstLeapYear) => {
const isoMonthInt = toInteger(isoMonth), isoDayInt = toInteger(isoDay), calendarId = refineCalendarArg(calendarArg);
return createPlainMonthDaySlots(checkIsoDateInBounds(checkIsoDateFields({
isoYear: toInteger(referenceIsoYear),
isoMonth: isoMonthInt,
isoDay: isoDayInt
})), calendarId);
}), refineCalendarId), {
...calendarIdGetters,
...monthDayGetters
}, {
with: (slots, mod, options) => createPlainMonthDay(((getCalendarOps, plainMonthDaySlots, modFields, options) => {
const calendarOps = getCalendarOps(plainMonthDaySlots.calendar), validFieldNames = calendarOps.fields(dateFieldNamesAlpha).sort(), origFields = (slots => {
const calendarOps = createNativePartOps(slots.calendar), [year, month, day] = calendarOps.dateParts(slots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month);
return {
monthCode: formatMonthCode(monthCodeNumber, isLeapMonth),
day: day
};
})(plainMonthDaySlots), partialFields = refineFields(modFields, validFieldNames), mergedFields = calendarOps.mergeFields(origFields, partialFields);
return calendarOps.monthDayFromFields(mergedFields, options);
})(createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
equals(slots, otherArg) {
return !compareIsoDateFields(plainMonthDaySlots0 = slots, plainMonthDaySlots1 = toPlainMonthDaySlots(otherArg)) && plainMonthDaySlots0.calendar === plainMonthDaySlots1.calendar;
var plainMonthDaySlots0, plainMonthDaySlots1;
},
toPlainDate(slots, bag) {
return createPlainDate(((getCalendarOps, plainMonthDaySlots, plainMonthDayFields, bag) => ((calendarOps, input, bag) => convertToIso(calendarOps, input, monthCodeDayFieldNames, requireObjectLike(bag), yearFieldNames))(getCalendarOps(plainMonthDaySlots.calendar), plainMonthDayFields, bag))(createNativeStandardOps, slots, this, bag));
},
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepPlainMonthDayFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: formatPlainMonthDayIso,
toJSON: slots => formatPlainMonthDayIso(slots),
valueOf: neverValueOf
}, {
from: (arg, options) => createPlainMonthDay(toPlainMonthDaySlots(arg, options))
}), [PlainYearMonth, createPlainYearMonth, getPlainYearMonthSlots] = createSlotClass(PlainYearMonthBranding, bindArgs(((refineCalendarArg, isoYear, isoMonth, calendarArg = isoCalendarId, referenceIsoDay = 1) => {
const isoYearInt = toInteger(isoYear), isoMonthInt = toInteger(isoMonth), calendarId = refineCalendarArg(calendarArg);
return createPlainYearMonthSlots(checkIsoYearMonthInBounds(checkIsoDateFields({
isoYear: isoYearInt,
isoMonth: isoMonthInt,
isoDay: toInteger(referenceIsoDay)
})), calendarId);
}), refineCalendarId), {
...calendarIdGetters,
...yearMonthGetters
}, {
with: (slots, mod, options) => createPlainYearMonth(((getCalendarOps, plainYearMonthSlots, modFields, options) => {
const calendarOps = getCalendarOps(plainYearMonthSlots.calendar), validFieldNames = calendarOps.fields(yearMonthFieldNames).sort(), origFields = (slots => {
const calendarOps = createNativePartOps(slots.calendar), [year, month] = calendarOps.dateParts(slots), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month);
return {
year: year,
monthCode: formatMonthCode(monthCodeNumber, isLeapMonth)
};
})(plainYearMonthSlots), partialFields = refineFields(modFields, validFieldNames), mergedFields = calendarOps.mergeFields(origFields, partialFields);
return calendarOps.yearMonthFromFields(mergedFields, options);
})(createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
add: (slots, durationArg, options) => createPlainYearMonth(movePlainYearMonth(createNativeStandardOps, 0, slots, toDurationSlots(durationArg), options)),
subtract: (slots, durationArg, options) => createPlainYearMonth(movePlainYearMonth(createNativeStandardOps, 1, slots, toDurationSlots(durationArg), options)),
until: (slots, otherArg, options) => createDuration(diffPlainYearMonth(createNativeStandardOps, 0, slots, toPlainYearMonthSlots(otherArg), options)),
since: (slots, otherArg, options) => createDuration(diffPlainYearMonth(createNativeStandardOps, 1, slots, toPlainYearMonthSlots(otherArg), options)),
equals(slots, otherArg) {
return !compareIsoDateFields(plainYearMonthSlots0 = slots, plainYearMonthSlots1 = toPlainYearMonthSlots(otherArg)) && plainYearMonthSlots0.calendar === plainYearMonthSlots1.calendar;
var plainYearMonthSlots0, plainYearMonthSlots1;
},
toPlainDate(slots, bag) {
return createPlainDate(((getCalendarOps, plainYearMonthSlots, plainYearMonthFields, bag) => ((calendarOps, input, bag) => convertToIso(calendarOps, input, yearMonthCodeFieldNames, requireObjectLike(bag), dayFieldNames))(getCalendarOps(plainYearMonthSlots.calendar), plainYearMonthFields, bag))(createNativeStandardOps, slots, this, bag));
},
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepPlainYearMonthFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: formatPlainYearMonthIso,
toJSON: slots => formatPlainYearMonthIso(slots),
valueOf: neverValueOf
}, {
from: (arg, options) => createPlainYearMonth(toPlainYearMonthSlots(arg, options)),
compare: (arg0, arg1) => compareIsoDateFields(toPlainYearMonthSlots(arg0), toPlainYearMonthSlots(arg1))
}), [PlainDate, createPlainDate, getPlainDateSlots] = createSlotClass(PlainDateBranding, bindArgs(((refineCalendarArg, isoYear, isoMonth, isoDay, calendarArg = isoCalendarId) => createPlainDateSlots(checkIsoDateInBounds(checkIsoDateFields(mapProps(toInteger, {
isoYear: isoYear,
isoMonth: isoMonth,
isoDay: isoDay
}))), refineCalendarArg(calendarArg))), refineCalendarId), {
...calendarIdGetters,
...dateGetters
}, {
with: (slots, mod, options) => createPlainDate(((getCalendarOps, plainDateSlots, modFields, options) => {
const calendarOps = getCalendarOps(plainDateSlots.calendar), validFieldNames = calendarOps.fields(dateFieldNamesAlpha).sort(), origFields = computeDateEssentials(plainDateSlots), partialFields = refineFields(modFields, validFieldNames), mergedFields = calendarOps.mergeFields(origFields, partialFields);
return calendarOps.dateFromFields(mergedFields, options);
})(createNativeStandardOps, slots, rejectInvalidBag(mod), options)),
withCalendar: (slots, calendarArg) => createPlainDate(slotsWithCalendarId(slots, refineCalendarArg(calendarArg))),
add: (slots, durationArg, options) => createPlainDate(movePlainDate(createNativeStandardOps, 0, slots, toDurationSlots(durationArg), options)),
subtract: (slots, durationArg, options) => createPlainDate(movePlainDate(createNativeStandardOps, 1, slots, toDurationSlots(durationArg), options)),
until: (slots, otherArg, options) => createDuration(diffPlainDates(createNativeStandardOps, 0, slots, toPlainDateSlots(otherArg), options)),
since: (slots, otherArg, options) => createDuration(diffPlainDates(createNativeStandardOps, 1, slots, toPlainDateSlots(otherArg), options)),
equals(slots, otherArg) {
return !compareIsoDateFields(plainDateSlots0 = slots, plainDateSlots1 = toPlainDateSlots(otherArg)) && plainDateSlots0.calendar === plainDateSlots1.calendar;
var plainDateSlots0, plainDateSlots1;
},
toZonedDateTime(slots, options) {
const optionsObj = isObjectLike(options) ? options : {
timeZone: options
};
return createZonedDateTime(((refineTimeZoneString, refinePlainTimeArg, getTimeZoneOps, plainDateSlots, options) => {
const timeZoneId = refineTimeZoneString(options.timeZone), plainTimeArg = options.plainTime, isoTimeFields = void 0 !== plainTimeArg ? refinePlainTimeArg(plainTimeArg) : void 0, timeZoneOps = getTimeZoneOps(timeZoneId);
let epochNano;
return epochNano = isoTimeFields ? getSingleInstantFor(timeZoneOps, {
...plainDateSlots,
...isoTimeFields
}) : getStartOfDayInstantFor(timeZoneOps, {
...plainDateSlots,
...isoTimeFieldDefaults
}), createZonedDateTimeSlots(epochNano, timeZoneId, plainDateSlots.calendar);
})(refineTimeZoneArg, toPlainTimeSlots, queryNativeTimeZone, slots, optionsObj));
},
toPlainDateTime: (slots, plainTimeArg) => createPlainDateTime(((plainDateSlots, plainTimeFields = isoTimeFieldDefaults) => createPlainDateTimeSlots(checkIsoDateTimeInBounds({
...plainDateSlots,
...plainTimeFields
})))(slots, optionalToPlainTimeFields(plainTimeArg))),
toPlainYearMonth(slots) {
return createPlainYearMonth((this, ((calendarOps, input) => {
const fields = refineCalendarFields(calendarOps, input, yearMonthCodeFieldNames);
return calendarOps.yearMonthFromFields(fields, void 0);
})(createNativeStandardOps(slots.calendar), this)));
},
toPlainMonthDay(slots) {
return createPlainMonthDay((this, ((calendarOps, input) => {
const fields = refineCalendarFields(calendarOps, input, monthCodeDayFieldNames);
return calendarOps.monthDayFromFields(fields);
})(createNativeStandardOps(slots.calendar), this)));
},
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepPlainDateFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: formatPlainDateIso,
toJSON: slots => formatPlainDateIso(slots),
valueOf: neverValueOf
}, {
from: (arg, options) => createPlainDate(toPlainDateSlots(arg, options)),
compare: (arg0, arg1) => compareIsoDateFields(toPlainDateSlots(arg0), toPlainDateSlots(arg1))
}), [ZonedDateTime, createZonedDateTime] = createSlotClass(ZonedDateTimeBranding, bindArgs(((refineCalendarArg, refineTimeZoneArg, epochNano, timeZoneArg, calendarArg = isoCalendarId) => createZonedDateTimeSlots(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(epochNano))), refineTimeZoneArg(timeZoneArg), refineCalendarArg(calendarArg))), refineCalendarId, (id => resolveTimeZoneId(requireString(id)))), {
...epochGetters,
...calendarIdGetters,
...adaptDateMethods(dateGetters),
...adaptDateMethods(timeGetters),
offset: slots => formatOffsetNano(slotsToIso(slots).offsetNanoseconds),
offsetNanoseconds: slots => slotsToIso(slots).offsetNanoseconds,
timeZoneId: slots => slots.timeZone,
hoursInDay: slots => ((getTimeZoneOps, slots) => {
const timeZoneOps = getTimeZoneOps(slots.timeZone), isoFields = zonedEpochSlotsToIso(slots, timeZoneOps), [isoFields0, isoFields1] = computeDayInterval(isoFields), hoursExact = bigNanoToNumber(diffBigNanos(getStartOfDayInstantFor(timeZoneOps, isoFields0), getStartOfDayInstantFor(timeZoneOps, isoFields1)), nanoInHour, 1);
if (hoursExact <= 0) {
throw new RangeError(invalidProtocolResults);
}
return hoursExact;
})(queryNativeTimeZone, slots)
}, {
with: (slots, mod, options) => createZonedDateTime(((getCalendarOps, getTimeZoneOps, zonedDateTimeSlots, modFields, options) => {
const {calendar: calendar, timeZone: timeZone} = zonedDateTimeSlots, calendarOps = getCalendarOps(calendar), timeZoneOps = getTimeZoneOps(timeZone), validFieldNames = [ ...calendarOps.fields(dateFieldNamesAlpha), ...timeAndOffsetFieldNames ].sort(), origFields = (slots => {
const isoFields = zonedEpochSlotsToIso(slots, queryNativeTimeZone), offsetString = formatOffsetNano(isoFields.offsetNanoseconds), calendarOps = createNativePartOps(slots.calendar), [year, month, day] = calendarOps.dateParts(isoFields), [monthCodeNumber, isLeapMonth] = calendarOps.monthCodeParts(year, month), monthCode = formatMonthCode(monthCodeNumber, isLeapMonth);
return {
...isoTimeFieldsToCal(isoFields),
year: year,
monthCode: monthCode,
day: day,
offset: offsetString
};
})(zonedDateTimeSlots), partialFields = refineFields(modFields, validFieldNames), mergedCalendarFields = calendarOps.mergeFields(origFields, partialFields), mergedAllFields = {
...origFields,
...partialFields
}, [overflow, offsetDisambig, epochDisambig] = refineZonedFieldOptions(options, 2);
return createZonedDateTimeSlots(getMatchingInstantFor(timeZoneOps, {
...calendarOps.dateFromFields(mergedCalendarFields, fabricateOverflowOptions(overflow)),
...constrainIsoTimeFields(timeFieldsToIso(mergedAllFields), overflow)
}, parseOffsetNano(mergedAllFields.offset), offsetDisambig, epochDisambig), timeZone, calendar);
})(createNativeStandardOps, queryNativeTimeZone, slots, rejectInvalidBag(mod), options)),
withCalendar: (slots, calendarArg) => createZonedDateTime(slotsWithCalendarId(slots, refineCalendarArg(calendarArg))),
withTimeZone: (slots, timeZoneArg) => createZonedDateTime(((slots, timeZoneId) => ({
...slots,
timeZone: timeZoneId
}))(slots, refineTimeZoneArg(timeZoneArg))),
withPlainTime: (slots, plainTimeArg) => createZonedDateTime(((getTimeZoneOps, zonedDateTimeSlots, plainTimeSlots) => {
const timeZoneId = zonedDateTimeSlots.timeZone, timeZoneOps = getTimeZoneOps(timeZoneId), isoFields = {
...zonedEpochSlotsToIso(zonedDateTimeSlots, timeZoneOps),
...plainTimeSlots || isoTimeFieldDefaults
};
let epochNano;
return epochNano = plainTimeSlots ? getMatchingInstantFor(timeZoneOps, isoFields, isoFields.offsetNanoseconds, 2) : getStartOfDayInstantFor(timeZoneOps, isoFields),
createZonedDateTimeSlots(epochNano, timeZoneId, zonedDateTimeSlots.calendar);
})(queryNativeTimeZone, slots, optionalToPlainTimeFields(plainTimeArg))),
add: (slots, durationArg, options) => createZonedDateTime(moveZonedDateTime(createNativeStandardOps, queryNativeTimeZone, 0, slots, toDurationSlots(durationArg), options)),
subtract: (slots, durationArg, options) => createZonedDateTime(moveZonedDateTime(createNativeStandardOps, queryNativeTimeZone, 1, slots, toDurationSlots(durationArg), options)),
until: (slots, otherArg, options) => createDuration(createDurationSlots(diffZonedDateTimes(createNativeStandardOps, queryNativeTimeZone, 0, slots, toZonedDateTimeSlots(otherArg), options))),
since: (slots, otherArg, options) => createDuration(createDurationSlots(diffZonedDateTimes(createNativeStandardOps, queryNativeTimeZone, 1, slots, toZonedDateTimeSlots(otherArg), options))),
round: (slots, options) => createZonedDateTime(((getTimeZoneOps, slots, options) => {
let {epochNanoseconds: epochNanoseconds, timeZone: timeZone, calendar: calendar} = slots;
const [smallestUnit, roundingInc, roundingMode] = refineRoundingOptions(options);
if (0 === smallestUnit && 1 === roundingInc) {
return slots;
}
const timeZoneOps = getTimeZoneOps(timeZone);
if (6 === smallestUnit) {
epochNanoseconds = ((computeInterval, timeZoneOps, slots, roundingMode) => {
const isoSlots = zonedEpochSlotsToIso(slots, timeZoneOps), [isoFields0, isoFields1] = computeInterval(isoSlots), epochNano = slots.epochNanoseconds, epochNano0 = getStartOfDayInstantFor(timeZoneOps, isoFields0), epochNano1 = getStartOfDayInstantFor(timeZoneOps, isoFields1);
if (bigNanoOutside(epochNano, epochNano0, epochNano1)) {
throw new RangeError(invalidProtocolResults);
}
return roundWithMode(computeEpochNanoFrac(epochNano, epochNano0, epochNano1), roundingMode) ? epochNano1 : epochNano0;
})(computeDayInterval, timeZoneOps, slots, roundingMode);
} else {
const offsetNano = timeZoneOps.getOffsetNanosecondsFor(epochNanoseconds);
epochNanoseconds = getMatchingInstantFor(timeZoneOps, roundDateTime(epochNanoToIso(epochNanoseconds, offsetNano), smallestUnit, roundingInc, roundingMode), offsetNano, 2, 0, 1);
}
return createZonedDateTimeSlots(epochNanoseconds, timeZone, calendar);
})(queryNativeTimeZone, slots, options)),
startOfDay: slots => createZonedDateTime(((getTimeZoneOps, slots) => {
const {timeZone: timeZone, calendar: calendar} = slots, epochNano1 = ((computeAlignment, timeZoneOps, slots) => getStartOfDayInstantFor(timeZoneOps, computeAlignment(zonedEpochSlotsToIso(slots, timeZoneOps))))(computeDayFloor, getTimeZoneOps(timeZone), slots);
return createZonedDateTimeSlots(epochNano1, timeZone, calendar);
})(queryNativeTimeZone, slots)),
equals(slots, otherArg) {
return !compareZonedDateTimes(zonedDateTimeSlots0 = slots, zonedDateTimeSlots1 = toZonedDateTimeSlots(otherArg)) && !!isTimeZoneIdsEqual(zonedDateTimeSlots0.timeZone, zonedDateTimeSlots1.timeZone) && zonedDateTimeSlots0.calendar === zonedDateTimeSlots1.calendar;
var zonedDateTimeSlots0, zonedDateTimeSlots1;
},
toInstant: slots => createInstant(createInstantSlots(slots.epochNanoseconds)),
toPlainDateTime: slots => createPlainDateTime(zonedDateTimeToPlainDateTime(queryNativeTimeZone, slots)),
toPlainDate: slots => createPlainDate(zonedDateTimeToPlainDate(queryNativeTimeZone, slots)),
toPlainTime: slots => createPlainTime(zonedDateTimeToPlainTime(queryNativeTimeZone, slots)),
toLocaleString(slots, locales, options = {}) {
const [format, epochMilli] = prepZonedDateTimeFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: (slots, options) => formatZonedDateTimeIso(queryNativeTimeZone, slots, options),
toJSON: slots => formatZonedDateTimeIso(queryNativeTimeZone, slots),
valueOf: neverValueOf,
getTimeZoneTransition(slots, options) {
const {timeZone: timeZoneId, epochNanoseconds: epochNano} = slots, direction = (options => {
const normalizedOptions = normalizeOptionsOrString(options, "direction"), res = refineChoiceOption("direction", directionMap, normalizedOptions, 0);
if (!res) {
throw new RangeError(invalidEntity("direction", res));
}
return res;
})(options), newEpochNano = queryNativeTimeZone(timeZoneId).getTransition(epochNano, direction);
return newEpochNano ? createZonedDateTime({
...slots,
epochNanoseconds: newEpochNano
}) : null;
}
}, {
from: (arg, options) => createZonedDateTime(toZonedDateTimeSlots(arg, options)),
compare: (arg0, arg1) => compareZonedDateTimes(toZonedDateTimeSlots(arg0), toZonedDateTimeSlots(arg1))
}), [Instant, createInstant, getInstantSlots] = createSlotClass(InstantBranding, (epochNano => createInstantSlots(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(epochNano))))), epochGetters, {
add: (slots, durationArg) => createInstant(moveInstant(0, slots, toDurationSlots(durationArg))),
subtract: (slots, durationArg) => createInstant(moveInstant(1, slots, toDurationSlots(durationArg))),
until: (slots, otherArg, options) => createDuration(diffInstants(0, slots, toInstantSlots(otherArg), options)),
since: (slots, otherArg, options) => createDuration(diffInstants(1, slots, toInstantSlots(otherArg), options)),
round: (slots, options) => createInstant(((instantSlots, options) => {
const [smallestUnit, roundingInc, roundingMode] = refineRoundingOptions(options, 5, 1);
return createInstantSlots(roundBigNano(instantSlots.epochNanoseconds, smallestUnit, roundingInc, roundingMode, 1));
})(slots, options)),
equals(slots, otherArg) {
return !compareInstants(slots, toInstantSlots(otherArg));
},
toZonedDateTimeISO: (slots, timeZoneArg) => createZonedDateTime(((instantSlots, timeZoneId, calendarId = isoCalendarId) => createZonedDateTimeSlots(instantSlots.epochNanoseconds, timeZoneId, calendarId))(slots, refineTimeZoneArg(timeZoneArg))),
toLocaleString(slots, locales, options) {
const [format, epochMilli] = prepInstantFormat(locales, options, slots);
return format.format(epochMilli);
},
toString: (slots, options) => formatInstantIso(refineTimeZoneArg, queryNativeTimeZone, slots, options),
toJSON: slots => formatInstantIso(refineTimeZoneArg, queryNativeTimeZone, slots),
valueOf: neverValueOf
}, {
from: arg => createInstant(toInstantSlots(arg)),
fromEpochMilliseconds: epochMilli => createInstant((epochMilli => createInstantSlots(checkEpochNanoInBounds(numberToBigNano(toStrictInteger(epochMilli), nanoInMilli))))(epochMilli)),
fromEpochNanoseconds: epochNano => createInstant((epochNano => createInstantSlots(checkEpochNanoInBounds(bigIntToBigNano(toBigInt(epochNano)))))(epochNano)),
compare: (a, b) => compareInstants(toInstantSlots(a), toInstantSlots(b))
}), 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 RawDateTimeFormat(locales, options), resolveOptions = rawFormat.resolvedOptions(), resolvedLocale = resolveOptions.locale, copiedOptions = pluckProps(Object.keys(options), resolveOptions), queryFormatPrepperForBranding = memoize(createFormatPrepperForBranding), prepFormat = (isRange, ...formattables) => {
if (isRange) {
if (2 !== formattables.length) {
throw new TypeError("Mismatching types for formatting");
}
for (const formattable of formattables) {
if (void 0 === formattable) {
throw new TypeError("Mismatching types for formatting");
}
}
}
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("Mismatching types for formatting");
}
overallBranding = slotsBranding;
}
return overallBranding ? queryFormatPrepperForBranding(overallBranding)(resolvedLocale, copiedOptions, ...formattableEssences) : [ rawFormat, ...formattableEssences ];
};
return prepFormat.rawFormat = rawFormat, prepFormat;
})(locales, options));
}
const members = RawDateTimeFormat.prototype, memberDescriptors = Object.getOwnPropertyDescriptors(members), classDescriptors = Object.getOwnPropertyDescriptors(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("Invalid calling context");
}
return (...args) => formatLikeMethod.apply(this, args);
}, Object.defineProperties(memberDescriptor.get, createNameDescriptors(`get ${memberName}`)));
}
return classDescriptors.prototype.value = DateTimeFormatNew.prototype = Object.create({}, memberDescriptors),
Object.defineProperties(DateTimeFormatFunc, classDescriptors), DateTimeFormatFunc;
}(), internalsMap = new WeakMap;
let currentTimeZoneId;
const Now = Object.defineProperties({}, {
...createStringTagDescriptors("Temporal.Now"),
...createPropDescriptors({
timeZoneId: () => getCurrentTimeZoneId(),
instant: () => createInstant(createInstantSlots(getCurrentEpochNano())),
zonedDateTimeISO: (timeZoneArg = getCurrentTimeZoneId()) => createZonedDateTime(createZonedDateTimeSlots(getCurrentEpochNano(), refineTimeZoneArg(timeZoneArg), isoCalendarId)),
plainDateTimeISO: (timeZoneArg = getCurrentTimeZoneId()) => createPlainDateTime(createPlainDateTimeSlots(getCurrentIsoDateTime(queryNativeTimeZone(refineTimeZoneArg(timeZoneArg))), isoCalendarId)),
plainDateISO: (timeZoneArg = getCurrentTimeZoneId()) => createPlainDate(createPlainDateSlots(getCurrentIsoDateTime(queryNativeTimeZone(refineTimeZoneArg(timeZoneArg))), isoCalendarId)),
plainTimeISO: (timeZoneArg = getCurrentTimeZoneId()) => createPlainTime(createPlainTimeSlots(getCurrentIsoDateTime(queryNativeTimeZone(refineTimeZoneArg(timeZoneArg)))))
})
}), Temporal = Object.defineProperties({}, {
...createStringTagDescriptors("Temporal"),
...createPropDescriptors({
PlainYearMonth: PlainYearMonth,
PlainMonthDay: PlainMonthDay,
PlainDate: PlainDate,
PlainTime: PlainTime,
PlainDateTime: PlainDateTime,
ZonedDateTime: ZonedDateTime,
Instant: Instant,
Duration: Duration,
Now: Now
})
});
Object.defineProperties(globalThis, createPropDescriptors({
Temporal: Temporal
})), Object.defineProperties(Intl, createPropDescriptors({
DateTimeFormat: DateTimeFormat
})), Object.defineProperties(Date.prototype, createPropDescriptors({
toTemporalInstant() {
const epochMilli = Date.prototype.valueOf.call(this);
return createInstant(createInstantSlots(numberToBigNano(requireNumberIsInteger(epochMilli), nanoInMilli)));
}
}));
}();