@full-ui/headless-calendar 7.0.0-beta.6 → 7.0.0-beta.8

package/{esm/index.d.ts → index.d.ts}

@@ -100,16 +100,6 @@ interface Locale {
     options: any;
 }
 
-declare abstract class NamedTimeZoneImpl {
-    timeZoneName: string;
-    constructor(timeZoneName: string);
-    abstract offsetForArray(a: number[]): number;
-    abstract timestampToArray(ms: number): number[];
-}
-type NamedTimeZoneImplClass = {
-    new (timeZoneName: string): NamedTimeZoneImpl;
-};
-
 interface ZonedMarker {
     marker: DateMarker;
     timeZoneOffset: number;
@@ -154,7 +144,6 @@ interface DateFormatter {
 type WeekNumberCalculation = 'local' | 'ISO' | ((m: Date) => number);
 interface DateEnvSettings {
     timeZone: string;
-    namedTimeZoneImpl?: NamedTimeZoneImplClass;
     calendarSystem: string;
     locale: Locale;
     weekNumberCalculation?: WeekNumberCalculation;
@@ -168,12 +157,9 @@ type DateInput = Date | string | number | number[];
 interface DateMarkerMeta {
     marker: DateMarker;
     isTimeUnspecified: boolean;
-    forcedTzo: number | null;
 }
 declare class DateEnv {
     timeZone: string;
-    namedTimeZoneImpl: NamedTimeZoneImpl;
-    canComputeOffset: boolean;
     calendarSystem: CalendarSystem;
     locale: Locale;
     weekDow: number;
@@ -190,7 +176,6 @@ declare class DateEnv {
     parse(s: string): {
         marker: Date;
         isTimeUnspecified: boolean;
-        forcedTzo: any;
     };
     getYear(marker: DateMarker): number;
     getMonth(marker: DateMarker): number;
@@ -211,19 +196,15 @@ declare class DateEnv {
     startOfMonth(m: DateMarker): DateMarker;
     startOfWeek(m: DateMarker): DateMarker;
     computeWeekNumber(marker: DateMarker): number;
-    format(marker: DateMarker, formatter: DateFormatter, dateOptions?: {
-        forcedTzo?: number;
-    }): [string, Intl.DateTimeFormatPart[]];
+    format(marker: DateMarker, formatter: DateFormatter): [string, Intl.DateTimeFormatPart[]];
     formatRange(start: DateMarker, end: DateMarker, formatter: DateFormatter, dateOptions?: {
-        forcedStartTzo?: number;
-        forcedEndTzo?: number;
         isEndExclusive?: boolean;
         defaultSeparator?: string;
     }): string;
     formatIso(marker: DateMarker, extraOptions?: any): string;
     timestampToMarker(ms: number): Date;
     offsetForMarker(m: DateMarker): number;
-    toDate(m: DateMarker, forcedTzo?: number): Date;
+    toDate(m: DateMarker): Date;
 }
 
 interface DateRangeInput {
@@ -281,4 +262,4 @@ declare function isInt(n: any): boolean;
 declare function trimEnd(s: string): string;
 declare function padStart(val: any, len: any): string;
 
-export { CalendarSystem, CmdFormatter, CmdFormatterFunc, DateEnv, DateEnvSettings, DateFormatter, DateFormattingContext, DateInput, DateMarker, DateMarkerMeta, DateRange, DateRangeInput, Duration, DurationInput, DurationObjectInput, ExpandedZonedMarker, FuncFormatter, FuncFormatterFunc, Locale, LocaleCodeArg, NamedTimeZoneImpl, NamedTimeZoneImplClass, OpenDateRange, VerboseFormattingData, WeekNumberCalculation, ZonedMarker, addDays, addDurations, addMs, addWeeks, arrayToLocalDate, arrayToUtcDate, asCleanDays, asRoughDays, asRoughHours, asRoughMinutes, asRoughMonths, asRoughMs, asRoughSeconds, asRoughYears, buildIsoString, constrainMarkerToRange, createCalendarSystem, createDuration, createVerboseFormattingArg, dateToLocalArray, dateToUtcArray, diffDayAndTime, diffDays, diffHours, diffMinutes, diffSeconds, diffWeeks, diffWholeDays, diffWholeWeeks, durationsEqual, expandZonedMarker, formatDayString, formatIsoMonthStr, formatIsoTimeString, formatTimeZoneOffset, greatestDurationDenominator, intersectRanges, invertRanges, isInt, isValidDate, joinDateTimeFormatParts, multiplyDuration, padStart, parse, parseRange, rangeContainsMarker, rangeContainsRange, rangesEqual, rangesIntersect, registerCalendarSystem, startOfDay, startOfHour, startOfMinute, startOfSecond, subtractDurations, timeAsMs, trimEnd, weekOfYear, wholeDivideDurations };
+export { CalendarSystem, CmdFormatter, CmdFormatterFunc, DateEnv, DateEnvSettings, DateFormatter, DateFormattingContext, DateInput, DateMarker, DateMarkerMeta, DateRange, DateRangeInput, Duration, DurationInput, DurationObjectInput, ExpandedZonedMarker, FuncFormatter, FuncFormatterFunc, Locale, LocaleCodeArg, OpenDateRange, VerboseFormattingData, WeekNumberCalculation, ZonedMarker, addDays, addDurations, addMs, addWeeks, arrayToLocalDate, arrayToUtcDate, asCleanDays, asRoughDays, asRoughHours, asRoughMinutes, asRoughMonths, asRoughMs, asRoughSeconds, asRoughYears, buildIsoString, constrainMarkerToRange, createCalendarSystem, createDuration, createVerboseFormattingArg, dateToLocalArray, dateToUtcArray, diffDayAndTime, diffDays, diffHours, diffMinutes, diffSeconds, diffWeeks, diffWholeDays, diffWholeWeeks, durationsEqual, expandZonedMarker, formatDayString, formatIsoMonthStr, formatIsoTimeString, formatTimeZoneOffset, greatestDurationDenominator, intersectRanges, invertRanges, isInt, isValidDate, joinDateTimeFormatParts, multiplyDuration, padStart, parse as parseMarker, parseRange, rangeContainsMarker, rangeContainsRange, rangesEqual, rangesIntersect, registerCalendarSystem, startOfDay, startOfHour, startOfMinute, startOfSecond, subtractDurations, timeAsMs, trimEnd, weekOfYear, wholeDivideDurations };

package/{esm/index.js → index.js}

@@ -1,3 +1,7 @@
+import * as ZonedDateTimeFns from 'temporal-polyfill/fns/zoneddatetime';
+import * as PlainDateTimeFns from 'temporal-polyfill/fns/plaindatetime';
+import * as InstantFns from 'temporal-polyfill/fns/instant';
+
 // Adding
 function addWeeks(m, n) {
     let a = dateToUtcArray(m);
@@ -564,12 +568,7 @@ function parse(str) {
 class DateEnv {
     constructor(settings) {
         var _a;
-        let timeZone = this.timeZone = settings.timeZone;
-        let isNamedTimeZone = timeZone !== 'local' && timeZone !== 'UTC';
-        if (settings.namedTimeZoneImpl && isNamedTimeZone) {
-            this.namedTimeZoneImpl = new settings.namedTimeZoneImpl(timeZone);
-        }
-        this.canComputeOffset = Boolean(!isNamedTimeZone || this.namedTimeZoneImpl);
+        this.timeZone = settings.timeZone;
         this.calendarSystem = createCalendarSystem(settings.calendarSystem);
         this.locale = settings.locale;
         this.weekDow = settings.locale.week.dow;
@@ -598,12 +597,7 @@ class DateEnv {
         return meta.marker;
     }
     createNowMarker() {
-        if (this.canComputeOffset) {
-            return this.timestampToMarker(new Date().valueOf());
-        }
-        // if we can't compute the current date val for a timezone,
-        // better to give the current local date vals than UTC
-        return arrayToUtcDate(dateToLocalArray(new Date()));
+        return this.timestampToMarker(new Date().valueOf());
     }
     createMarkerMeta(input) {
         if (typeof input === 'string') {
@@ -625,7 +619,7 @@ class DateEnv {
         if (marker === null || !isValidDate(marker)) {
             return null;
         }
-        return { marker, isTimeUnspecified: false, forcedTzo: null };
+        return { marker, isTimeUnspecified: false };
     }
     parse(s) {
         let parts = parse(s);
@@ -633,16 +627,10 @@ class DateEnv {
             return null;
         }
         let { marker } = parts;
-        let forcedTzo = null;
         if (parts.timeZoneOffset !== null) {
-            if (this.canComputeOffset) {
-                marker = this.timestampToMarker(marker.valueOf() - parts.timeZoneOffset * 60 * 1000);
-            }
-            else {
-                forcedTzo = parts.timeZoneOffset;
-            }
+            marker = this.timestampToMarker(marker.valueOf() - parts.timeZoneOffset * 60 * 1000);
         }
-        return { marker, isTimeUnspecified: parts.isTimeUnspecified, forcedTzo };
+        return { marker, isTimeUnspecified: parts.isTimeUnspecified };
     }
     // Accessors
     getYear(marker) {
@@ -807,12 +795,10 @@ class DateEnv {
         return weekOfYear(marker, this.weekDow, this.weekDoy);
     }
     // TODO: choke on timeZoneName: long
-    format(marker, formatter, dateOptions = {}) {
+    format(marker, formatter) {
         return formatter.format({
             marker,
-            timeZoneOffset: dateOptions.forcedTzo != null ?
-                dateOptions.forcedTzo :
-                this.offsetForMarker(marker),
+            timeZoneOffset: this.offsetForMarker(marker),
         }, this);
     }
     // Unlike format(), returns plain string!
@@ -822,14 +808,10 @@ class DateEnv {
         }
         return formatter.formatRange({
             marker: start,
-            timeZoneOffset: dateOptions.forcedStartTzo != null ?
-                dateOptions.forcedStartTzo :
-                this.offsetForMarker(start),
+            timeZoneOffset: this.offsetForMarker(start),
         }, {
             marker: end,
-            timeZoneOffset: dateOptions.forcedEndTzo != null ?
-                dateOptions.forcedEndTzo :
-                this.offsetForMarker(end),
+            timeZoneOffset: this.offsetForMarker(end),
         }, this, dateOptions.defaultSeparator);
     }
     /*
@@ -839,12 +821,7 @@ class DateEnv {
     formatIso(marker, extraOptions = {}) {
         let timeZoneOffset = null;
         if (!extraOptions.omitTimeZoneOffset) {
-            if (extraOptions.forcedTzo != null) {
-                timeZoneOffset = extraOptions.forcedTzo;
-            }
-            else {
-                timeZoneOffset = this.offsetForMarker(marker);
-            }
+            timeZoneOffset = this.offsetForMarker(marker);
         }
         return buildIsoString(marker, timeZoneOffset, extraOptions.omitTime);
     }
@@ -853,10 +830,12 @@ class DateEnv {
         if (this.timeZone === 'local') {
             return arrayToUtcDate(dateToLocalArray(new Date(ms)));
         }
-        if (this.timeZone === 'UTC' || !this.namedTimeZoneImpl) {
+        if (this.timeZone === 'UTC') {
             return new Date(ms);
         }
-        return arrayToUtcDate(this.namedTimeZoneImpl.timestampToArray(ms));
+        const zdtFields = ZonedDateTimeFns.getFields(InstantFns.toZonedDateTimeISO(InstantFns.fromEpochMilliseconds(ms), this.timeZone));
+        return new Date(// a "Date Marker", which is like PlainDateTime
+        Date.UTC(zdtFields.year, zdtFields.month - 1, zdtFields.day, zdtFields.hour, zdtFields.minute, zdtFields.second, zdtFields.millisecond));
     }
     offsetForMarker(m) {
         if (this.timeZone === 'local') {
@@ -865,24 +844,17 @@ class DateEnv {
         if (this.timeZone === 'UTC') {
             return 0;
         }
-        if (this.namedTimeZoneImpl) {
-            return this.namedTimeZoneImpl.offsetForArray(dateToUtcArray(m));
-        }
-        return null;
+        return ZonedDateTimeFns.offsetNanoseconds(PlainDateTimeFns.toZonedDateTime(PlainDateTimeFns.create(m.getUTCFullYear(), m.getUTCMonth() + 1, m.getUTCDate(), m.getUTCHours(), m.getUTCMinutes(), m.getUTCSeconds(), m.getUTCMilliseconds()), this.timeZone)) / (1000000000 * 60);
     }
     // Conversion
-    toDate(m, forcedTzo) {
+    toDate(m) {
         if (this.timeZone === 'local') {
             return arrayToLocalDate(dateToUtcArray(m));
         }
         if (this.timeZone === 'UTC') {
             return new Date(m.valueOf()); // make sure it's a copy
         }
-        if (!this.namedTimeZoneImpl) {
-            return new Date(m.valueOf() - (forcedTzo || 0));
-        }
-        return new Date(m.valueOf() -
-            this.namedTimeZoneImpl.offsetForArray(dateToUtcArray(m)) * 1000 * 60);
+        return new Date(ZonedDateTimeFns.epochMilliseconds(PlainDateTimeFns.toZonedDateTime(PlainDateTimeFns.create(m.getUTCFullYear(), m.getUTCMonth() + 1, m.getUTCDate(), m.getUTCHours(), m.getUTCMinutes(), m.getUTCSeconds(), m.getUTCMilliseconds()), this.timeZone)));
     }
 }
 
@@ -936,10 +908,4 @@ class FuncFormatter {
     }
 }
 
-class NamedTimeZoneImpl {
-    constructor(timeZoneName) {
-        this.timeZoneName = timeZoneName;
-    }
-}
-
-export { CmdFormatter, DateEnv, FuncFormatter, NamedTimeZoneImpl, addDays, addDurations, addMs, addWeeks, arrayToLocalDate, arrayToUtcDate, asCleanDays, asRoughDays, asRoughHours, asRoughMinutes, asRoughMonths, asRoughMs, asRoughSeconds, asRoughYears, buildIsoString, constrainMarkerToRange, createCalendarSystem, createDuration, createVerboseFormattingArg, dateToLocalArray, dateToUtcArray, diffDayAndTime, diffDays, diffHours, diffMinutes, diffSeconds, diffWeeks, diffWholeDays, diffWholeWeeks, durationsEqual, expandZonedMarker, formatDayString, formatIsoMonthStr, formatIsoTimeString, formatTimeZoneOffset, greatestDurationDenominator, intersectRanges, invertRanges, isInt, isValidDate, joinDateTimeFormatParts, multiplyDuration, padStart, parse, parseRange, rangeContainsMarker, rangeContainsRange, rangesEqual, rangesIntersect, registerCalendarSystem, startOfDay, startOfHour, startOfMinute, startOfSecond, subtractDurations, timeAsMs, trimEnd, weekOfYear, wholeDivideDurations };
+export { CmdFormatter, DateEnv, FuncFormatter, addDays, addDurations, addMs, addWeeks, arrayToLocalDate, arrayToUtcDate, asCleanDays, asRoughDays, asRoughHours, asRoughMinutes, asRoughMonths, asRoughMs, asRoughSeconds, asRoughYears, buildIsoString, constrainMarkerToRange, createCalendarSystem, createDuration, createVerboseFormattingArg, dateToLocalArray, dateToUtcArray, diffDayAndTime, diffDays, diffHours, diffMinutes, diffSeconds, diffWeeks, diffWholeDays, diffWholeWeeks, durationsEqual, expandZonedMarker, formatDayString, formatIsoMonthStr, formatIsoTimeString, formatTimeZoneOffset, greatestDurationDenominator, intersectRanges, invertRanges, isInt, isValidDate, joinDateTimeFormatParts, multiplyDuration, padStart, parse as parseMarker, parseRange, rangeContainsMarker, rangeContainsRange, rangesEqual, rangesIntersect, registerCalendarSystem, startOfDay, startOfHour, startOfMinute, startOfSecond, subtractDurations, timeAsMs, trimEnd, weekOfYear, wholeDivideDurations };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@full-ui/headless-calendar",
-  "version": "7.0.0-beta.6",
+  "version": "7.0.0-beta.8",
   "keywords": [
     "headless",
     "calendar",
@@ -8,6 +8,9 @@
   ],
   "title": "Headless Calendar Library",
   "description": "Headless calendar library by the makers of FullCalendar",
+  "peerDependencies": {
+    "temporal-polyfill": "^0.3.2"
+  },
   "type": "module",
   "homepage": "https://fullcalendar.io",
   "bugs": "https://fullcalendar.io/reporting-bugs",
@@ -23,17 +26,13 @@
     "url": "http://arshaw.com/"
   },
   "copyright": "2025 Adam Shaw",
-  "types": "./esm/index.d.ts",
-  "module": "./esm/index.js",
-  "main": "./cjs/index.cjs",
+  "types": "./index.d.ts",
+  "main": "./index.js",
   "exports": {
     "./package.json": "./package.json",
     ".": {
-      "import": {
-        "types": "./esm/index.d.ts",
-        "default": "./esm/index.js"
-      },
-      "require": "./cjs/index.cjs"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     }
   },
   "sideEffects": false

package/cjs/index.cjs

@@ -1,1011 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-// Adding
-function addWeeks(m, n) {
-    let a = dateToUtcArray(m);
-    a[2] += n * 7;
-    return arrayToUtcDate(a);
-}
-function addDays(m, n) {
-    let a = dateToUtcArray(m);
-    a[2] += n;
-    return arrayToUtcDate(a);
-}
-function addMs(m, n) {
-    let a = dateToUtcArray(m);
-    a[6] += n;
-    return arrayToUtcDate(a);
-}
-// Diffing (all return floats)
-// TODO: why not use ranges?
-function diffWeeks(m0, m1) {
-    return diffDays(m0, m1) / 7;
-}
-function diffDays(m0, m1) {
-    return (m1.valueOf() - m0.valueOf()) / (1000 * 60 * 60 * 24);
-}
-function diffHours(m0, m1) {
-    return (m1.valueOf() - m0.valueOf()) / (1000 * 60 * 60);
-}
-function diffMinutes(m0, m1) {
-    return (m1.valueOf() - m0.valueOf()) / (1000 * 60);
-}
-function diffSeconds(m0, m1) {
-    return (m1.valueOf() - m0.valueOf()) / 1000;
-}
-function diffDayAndTime(m0, m1) {
-    let m0day = startOfDay(m0);
-    let m1day = startOfDay(m1);
-    return {
-        years: 0,
-        months: 0,
-        days: Math.round(diffDays(m0day, m1day)),
-        milliseconds: (m1.valueOf() - m1day.valueOf()) - (m0.valueOf() - m0day.valueOf()),
-    };
-}
-// Diffing Whole Units
-function diffWholeWeeks(m0, m1) {
-    let d = diffWholeDays(m0, m1);
-    if (d !== null && d % 7 === 0) {
-        return d / 7;
-    }
-    return null;
-}
-function diffWholeDays(m0, m1) {
-    if (timeAsMs(m0) === timeAsMs(m1)) {
-        return Math.round(diffDays(m0, m1));
-    }
-    return null;
-}
-// Start-Of
-function startOfDay(m) {
-    return arrayToUtcDate([
-        m.getUTCFullYear(),
-        m.getUTCMonth(),
-        m.getUTCDate(),
-    ]);
-}
-function startOfHour(m) {
-    return arrayToUtcDate([
-        m.getUTCFullYear(),
-        m.getUTCMonth(),
-        m.getUTCDate(),
-        m.getUTCHours(),
-    ]);
-}
-function startOfMinute(m) {
-    return arrayToUtcDate([
-        m.getUTCFullYear(),
-        m.getUTCMonth(),
-        m.getUTCDate(),
-        m.getUTCHours(),
-        m.getUTCMinutes(),
-    ]);
-}
-function startOfSecond(m) {
-    return arrayToUtcDate([
-        m.getUTCFullYear(),
-        m.getUTCMonth(),
-        m.getUTCDate(),
-        m.getUTCHours(),
-        m.getUTCMinutes(),
-        m.getUTCSeconds(),
-    ]);
-}
-// Week Computation
-function weekOfYear(marker, dow, doy) {
-    let y = marker.getUTCFullYear();
-    let w = weekOfGivenYear(marker, y, dow, doy);
-    if (w < 1) {
-        return weekOfGivenYear(marker, y - 1, dow, doy);
-    }
-    let nextW = weekOfGivenYear(marker, y + 1, dow, doy);
-    if (nextW >= 1) {
-        return Math.min(w, nextW);
-    }
-    return w;
-}
-function weekOfGivenYear(marker, year, dow, doy) {
-    let firstWeekStart = arrayToUtcDate([year, 0, 1 + firstWeekOffset(year, dow, doy)]);
-    let dayStart = startOfDay(marker);
-    let days = Math.round(diffDays(firstWeekStart, dayStart));
-    return Math.floor(days / 7) + 1; // zero-indexed
-}
-// start-of-first-week - start-of-year
-function firstWeekOffset(year, dow, doy) {
-    // first-week day -- which january is always in the first week (4 for iso, 1 for other)
-    let fwd = 7 + dow - doy;
-    // first-week day local weekday -- which local weekday is fwd
-    let fwdlw = (7 + arrayToUtcDate([year, 0, fwd]).getUTCDay() - dow) % 7;
-    return -fwdlw + fwd - 1;
-}
-// Array Conversion
-function dateToLocalArray(date) {
-    return [
-        date.getFullYear(),
-        date.getMonth(),
-        date.getDate(),
-        date.getHours(),
-        date.getMinutes(),
-        date.getSeconds(),
-        date.getMilliseconds(),
-    ];
-}
-function arrayToLocalDate(a) {
-    return new Date(a[0], a[1] || 0, a[2] == null ? 1 : a[2], // day of month
-    a[3] || 0, a[4] || 0, a[5] || 0);
-}
-function dateToUtcArray(date) {
-    return [
-        date.getUTCFullYear(),
-        date.getUTCMonth(),
-        date.getUTCDate(),
-        date.getUTCHours(),
-        date.getUTCMinutes(),
-        date.getUTCSeconds(),
-        date.getUTCMilliseconds(),
-    ];
-}
-function arrayToUtcDate(a) {
-    // according to web standards (and Safari), a month index is required.
-    // massage if only given a year.
-    if (a.length === 1) {
-        a = a.concat([0]);
-    }
-    return new Date(Date.UTC(...a));
-}
-// Other Utils
-function isValidDate(m) {
-    return !isNaN(m.valueOf());
-}
-function timeAsMs(m) {
-    return m.getUTCHours() * 1000 * 60 * 60 +
-        m.getUTCMinutes() * 1000 * 60 +
-        m.getUTCSeconds() * 1000 +
-        m.getUTCMilliseconds();
-}
-
-let calendarSystemClassMap = {};
-function registerCalendarSystem(name, theClass) {
-    calendarSystemClassMap[name] = theClass;
-}
-function createCalendarSystem(name) {
-    return new calendarSystemClassMap[name]();
-}
-class GregorianCalendarSystem {
-    getMarkerYear(d) {
-        return d.getUTCFullYear();
-    }
-    getMarkerMonth(d) {
-        return d.getUTCMonth();
-    }
-    getMarkerDay(d) {
-        return d.getUTCDate();
-    }
-    arrayToMarker(arr) {
-        return arrayToUtcDate(arr);
-    }
-    markerToArray(marker) {
-        return dateToUtcArray(marker);
-    }
-}
-registerCalendarSystem('gregory', GregorianCalendarSystem);
-
-function parseRange(input, dateEnv) {
-    let start = null;
-    let end = null;
-    if (input.start) {
-        start = dateEnv.createMarker(input.start);
-    }
-    if (input.end) {
-        end = dateEnv.createMarker(input.end);
-    }
-    if (!start && !end) {
-        return null;
-    }
-    if (start && end && end < start) {
-        return null;
-    }
-    return { start, end };
-}
-// SIDE-EFFECT: will mutate ranges.
-// Will return a new array result.
-function invertRanges(ranges, constraintRange) {
-    let invertedRanges = [];
-    let { start } = constraintRange; // the end of the previous range. the start of the new range
-    let i;
-    let dateRange;
-    // ranges need to be in order. required for our date-walking algorithm
-    ranges.sort(compareRanges);
-    for (i = 0; i < ranges.length; i += 1) {
-        dateRange = ranges[i];
-        // add the span of time before the event (if there is any)
-        if (dateRange.start > start) { // compare millisecond time (skip any ambig logic)
-            invertedRanges.push({ start, end: dateRange.start });
-        }
-        if (dateRange.end > start) {
-            start = dateRange.end;
-        }
-    }
-    // add the span of time after the last event (if there is any)
-    if (start < constraintRange.end) { // compare millisecond time (skip any ambig logic)
-        invertedRanges.push({ start, end: constraintRange.end });
-    }
-    return invertedRanges;
-}
-function compareRanges(range0, range1) {
-    return range0.start.valueOf() - range1.start.valueOf(); // earlier ranges go first
-}
-function intersectRanges(range0, range1) {
-    let { start, end } = range0;
-    let newRange = null;
-    if (range1.start !== null) {
-        if (start === null) {
-            start = range1.start;
-        }
-        else {
-            start = new Date(Math.max(start.valueOf(), range1.start.valueOf()));
-        }
-    }
-    if (range1.end != null) {
-        if (end === null) {
-            end = range1.end;
-        }
-        else {
-            end = new Date(Math.min(end.valueOf(), range1.end.valueOf()));
-        }
-    }
-    if (start === null || end === null || start < end) {
-        newRange = { start, end };
-    }
-    return newRange;
-}
-function rangesEqual(range0, range1) {
-    return (range0.start === null ? null : range0.start.valueOf()) === (range1.start === null ? null : range1.start.valueOf()) &&
-        (range0.end === null ? null : range0.end.valueOf()) === (range1.end === null ? null : range1.end.valueOf());
-}
-function rangesIntersect(range0, range1) {
-    return (range0.end === null || range1.start === null || range0.end > range1.start) &&
-        (range0.start === null || range1.end === null || range0.start < range1.end);
-}
-function rangeContainsRange(outerRange, innerRange) {
-    return (outerRange.start === null || (innerRange.start !== null && innerRange.start >= outerRange.start)) &&
-        (outerRange.end === null || (innerRange.end !== null && innerRange.end <= outerRange.end));
-}
-function rangeContainsMarker(range, date) {
-    return (range.start === null || date >= range.start) &&
-        (range.end === null || date < range.end);
-}
-// If the given date is not within the given range, move it inside.
-// (If it's past the end, make it one millisecond before the end).
-function constrainMarkerToRange(date, range) {
-    if (range.start != null && date < range.start) {
-        return range.start;
-    }
-    if (range.end != null && date >= range.end) {
-        return new Date(range.end.valueOf() - 1);
-    }
-    return date;
-}
-
-function expandZonedMarker(dateInfo, calendarSystem) {
-    let a = calendarSystem.markerToArray(dateInfo.marker);
-    return {
-        marker: dateInfo.marker,
-        timeZoneOffset: dateInfo.timeZoneOffset,
-        array: a,
-        year: a[0],
-        month: a[1],
-        day: a[2],
-        hour: a[3],
-        minute: a[4],
-        second: a[5],
-        millisecond: a[6],
-    };
-}
-
-function createVerboseFormattingArg(start, end, context, betterDefaultSeparator) {
-    let startInfo = expandZonedMarker(start, context.calendarSystem);
-    let endInfo = end ? expandZonedMarker(end, context.calendarSystem) : null;
-    return {
-        date: startInfo,
-        start: startInfo,
-        end: endInfo,
-        timeZone: context.timeZone,
-        localeCodes: context.locale.codes,
-        defaultSeparator: betterDefaultSeparator || context.defaultSeparator,
-    };
-}
-
-function isInt(n) {
-    return n % 1 === 0;
-}
-function trimEnd(s) {
-    return s.replace(/\s+$/, '');
-}
-function padStart(val, len) {
-    let s = String(val);
-    return '000'.substr(0, len - s.length) + s;
-}
-
-const INTERNAL_UNITS = ['years', 'months', 'days', 'milliseconds'];
-const PARSE_RE = /^(-?)(?:(\d+)\.)?(\d+):(\d\d)(?::(\d\d)(?:\.(\d\d\d))?)?/;
-// Parsing and Creation
-function createDuration(input, unit) {
-    if (typeof input === 'string') {
-        return parseString(input);
-    }
-    if (typeof input === 'object' && input) { // non-null object
-        return parseObject(input);
-    }
-    if (typeof input === 'number') {
-        return parseObject({ [unit || 'milliseconds']: input });
-    }
-    return null;
-}
-function parseString(s) {
-    let m = PARSE_RE.exec(s);
-    if (m) {
-        let sign = m[1] ? -1 : 1;
-        return {
-            years: 0,
-            months: 0,
-            days: sign * (m[2] ? parseInt(m[2], 10) : 0),
-            milliseconds: sign * ((m[3] ? parseInt(m[3], 10) : 0) * 60 * 60 * 1000 + // hours
-                (m[4] ? parseInt(m[4], 10) : 0) * 60 * 1000 + // minutes
-                (m[5] ? parseInt(m[5], 10) : 0) * 1000 + // seconds
-                (m[6] ? parseInt(m[6], 10) : 0) // ms
-            ),
-        };
-    }
-    return null;
-}
-function parseObject(obj) {
-    let duration = {
-        years: obj.years || obj.year || 0,
-        months: obj.months || obj.month || 0,
-        days: obj.days || obj.day || 0,
-        milliseconds: (obj.hours || obj.hour || 0) * 60 * 60 * 1000 + // hours
-            (obj.minutes || obj.minute || 0) * 60 * 1000 + // minutes
-            (obj.seconds || obj.second || 0) * 1000 + // seconds
-            (obj.milliseconds || obj.millisecond || obj.ms || 0), // ms
-    };
-    let weeks = obj.weeks || obj.week;
-    if (weeks) {
-        duration.days += weeks * 7;
-        duration.specifiedWeeks = true;
-    }
-    return duration;
-}
-// Equality
-function durationsEqual(d0, d1) {
-    return d0.years === d1.years &&
-        d0.months === d1.months &&
-        d0.days === d1.days &&
-        d0.milliseconds === d1.milliseconds;
-}
-function asCleanDays(dur) {
-    if (!dur.years && !dur.months && !dur.milliseconds) {
-        return dur.days;
-    }
-    return 0;
-}
-// Simple Math
-function addDurations(d0, d1) {
-    return {
-        years: d0.years + d1.years,
-        months: d0.months + d1.months,
-        days: d0.days + d1.days,
-        milliseconds: d0.milliseconds + d1.milliseconds,
-    };
-}
-function subtractDurations(d1, d0) {
-    return {
-        years: d1.years - d0.years,
-        months: d1.months - d0.months,
-        days: d1.days - d0.days,
-        milliseconds: d1.milliseconds - d0.milliseconds,
-    };
-}
-function multiplyDuration(d, n) {
-    return {
-        years: d.years * n,
-        months: d.months * n,
-        days: d.days * n,
-        milliseconds: d.milliseconds * n,
-    };
-}
-// Conversions
-// "Rough" because they are based on average-case Gregorian months/years
-function asRoughYears(dur) {
-    return asRoughDays(dur) / 365;
-}
-function asRoughMonths(dur) {
-    return asRoughDays(dur) / 30;
-}
-function asRoughDays(dur) {
-    return asRoughMs(dur) / 864e5;
-}
-function asRoughHours(dur) {
-    return asRoughMs(dur) / (1000 * 60 * 60);
-}
-function asRoughMinutes(dur) {
-    return asRoughMs(dur) / (1000 * 60);
-}
-function asRoughSeconds(dur) {
-    return asRoughMs(dur) / 1000;
-}
-function asRoughMs(dur) {
-    return dur.years * (365 * 864e5) +
-        dur.months * (30 * 864e5) +
-        dur.days * 864e5 +
-        dur.milliseconds;
-}
-// Advanced Math
-function wholeDivideDurations(numerator, denominator) {
-    let res = null;
-    for (let i = 0; i < INTERNAL_UNITS.length; i += 1) {
-        let unit = INTERNAL_UNITS[i];
-        if (denominator[unit]) {
-            let localRes = numerator[unit] / denominator[unit];
-            if (!isInt(localRes) || (res !== null && res !== localRes)) {
-                return null;
-            }
-            res = localRes;
-        }
-        else if (numerator[unit]) {
-            // needs to divide by something but can't!
-            return null;
-        }
-    }
-    return res;
-}
-function greatestDurationDenominator(dur) {
-    let ms = dur.milliseconds;
-    if (ms) {
-        if (ms % 1000 !== 0) {
-            return { unit: 'millisecond', value: ms };
-        }
-        if (ms % (1000 * 60) !== 0) {
-            return { unit: 'second', value: ms / 1000 };
-        }
-        if (ms % (1000 * 60 * 60) !== 0) {
-            return { unit: 'minute', value: ms / (1000 * 60) };
-        }
-        if (ms) {
-            return { unit: 'hour', value: ms / (1000 * 60 * 60) };
-        }
-    }
-    if (dur.days) {
-        if (dur.specifiedWeeks && dur.days % 7 === 0) {
-            return { unit: 'week', value: dur.days / 7 };
-        }
-        return { unit: 'day', value: dur.days };
-    }
-    if (dur.months) {
-        return { unit: 'month', value: dur.months };
-    }
-    if (dur.years) {
-        return { unit: 'year', value: dur.years };
-    }
-    return { unit: 'millisecond', value: 0 };
-}
-
-// timeZoneOffset is in minutes
-function buildIsoString(marker, timeZoneOffset, stripZeroTime = false) {
-    let s = marker.toISOString();
-    s = s.replace('.000', '');
-    if (stripZeroTime) {
-        s = s.replace('T00:00:00Z', '');
-    }
-    if (s.length > 10) { // time part wasn't stripped, can add timezone info
-        if (timeZoneOffset == null) {
-            s = s.replace('Z', '');
-        }
-        else if (timeZoneOffset !== 0) {
-            s = s.replace('Z', formatTimeZoneOffset(timeZoneOffset, true));
-        }
-        // otherwise, its UTC-0 and we want to keep the Z
-    }
-    return s;
-}
-// formats the date, but with no time part
-// TODO: somehow merge with buildIsoString and stripZeroTime
-// TODO: rename. omit "string"
-function formatDayString(marker) {
-    return marker.toISOString().replace(/T.*$/, '');
-}
-function formatIsoMonthStr(marker) {
-    return marker.toISOString().match(/^\d{4}-\d{2}/)[0];
-}
-// TODO: use Date::toISOString and use everything after the T?
-function formatIsoTimeString(marker) {
-    return padStart(marker.getUTCHours(), 2) + ':' +
-        padStart(marker.getUTCMinutes(), 2) + ':' +
-        padStart(marker.getUTCSeconds(), 2);
-}
-function formatTimeZoneOffset(minutes, doIso = false) {
-    let sign = minutes < 0 ? '-' : '+';
-    let abs = Math.abs(minutes);
-    let hours = Math.floor(abs / 60);
-    let mins = Math.round(abs % 60);
-    if (doIso) {
-        return `${sign + padStart(hours, 2)}:${padStart(mins, 2)}`;
-    }
-    return `GMT${sign}${hours}${mins ? `:${padStart(mins, 2)}` : ''}`;
-}
-function joinDateTimeFormatParts(parts) {
-    let s = '';
-    for (const part of parts) {
-        s += part.value;
-    }
-    return s;
-}
-
-const ISO_RE = /^\s*(\d{4})(-?(\d{2})(-?(\d{2})([T ](\d{2}):?(\d{2})(:?(\d{2})(\.(\d+))?)?(Z|(([-+])(\d{2})(:?(\d{2}))?))?)?)?)?$/;
-function parse(str) {
-    let m = ISO_RE.exec(str);
-    if (m) {
-        let marker = new Date(Date.UTC(Number(m[1]), m[3] ? Number(m[3]) - 1 : 0, Number(m[5] || 1), Number(m[7] || 0), Number(m[8] || 0), Number(m[10] || 0), m[12] ? Number(`0.${m[12]}`) * 1000 : 0));
-        if (isValidDate(marker)) {
-            let timeZoneOffset = null;
-            if (m[13]) {
-                timeZoneOffset = (m[15] === '-' ? -1 : 1) * (Number(m[16] || 0) * 60 +
-                    Number(m[18] || 0));
-            }
-            return {
-                marker,
-                isTimeUnspecified: !m[6],
-                timeZoneOffset,
-            };
-        }
-    }
-    return null;
-}
-
-class DateEnv {
-    constructor(settings) {
-        var _a;
-        let timeZone = this.timeZone = settings.timeZone;
-        let isNamedTimeZone = timeZone !== 'local' && timeZone !== 'UTC';
-        if (settings.namedTimeZoneImpl && isNamedTimeZone) {
-            this.namedTimeZoneImpl = new settings.namedTimeZoneImpl(timeZone);
-        }
-        this.canComputeOffset = Boolean(!isNamedTimeZone || this.namedTimeZoneImpl);
-        this.calendarSystem = createCalendarSystem(settings.calendarSystem);
-        this.locale = settings.locale;
-        this.weekDow = settings.locale.week.dow;
-        this.weekDoy = settings.locale.week.doy;
-        if (settings.weekNumberCalculation === 'ISO') {
-            this.weekDow = 1;
-            this.weekDoy = 4;
-        }
-        if (typeof settings.firstDay === 'number') {
-            this.weekDow = settings.firstDay;
-        }
-        if (typeof settings.weekNumberCalculation === 'function') {
-            this.weekNumberFunc = settings.weekNumberCalculation;
-        }
-        this.weekText = settings.weekText;
-        this.weekTextShort = (_a = settings.weekTextShort) !== null && _a !== void 0 ? _a : settings.weekText;
-        this.cmdFormatter = settings.cmdFormatter;
-        this.defaultSeparator = settings.defaultSeparator;
-    }
-    // Creating / Parsing
-    createMarker(input) {
-        let meta = this.createMarkerMeta(input);
-        if (meta === null) {
-            return null;
-        }
-        return meta.marker;
-    }
-    createNowMarker() {
-        if (this.canComputeOffset) {
-            return this.timestampToMarker(new Date().valueOf());
-        }
-        // if we can't compute the current date val for a timezone,
-        // better to give the current local date vals than UTC
-        return arrayToUtcDate(dateToLocalArray(new Date()));
-    }
-    createMarkerMeta(input) {
-        if (typeof input === 'string') {
-            return this.parse(input);
-        }
-        let marker = null;
-        if (typeof input === 'number') {
-            marker = this.timestampToMarker(input);
-        }
-        else if (input instanceof Date) {
-            input = input.valueOf();
-            if (!isNaN(input)) {
-                marker = this.timestampToMarker(input);
-            }
-        }
-        else if (Array.isArray(input)) {
-            marker = arrayToUtcDate(input);
-        }
-        if (marker === null || !isValidDate(marker)) {
-            return null;
-        }
-        return { marker, isTimeUnspecified: false, forcedTzo: null };
-    }
-    parse(s) {
-        let parts = parse(s);
-        if (parts === null) {
-            return null;
-        }
-        let { marker } = parts;
-        let forcedTzo = null;
-        if (parts.timeZoneOffset !== null) {
-            if (this.canComputeOffset) {
-                marker = this.timestampToMarker(marker.valueOf() - parts.timeZoneOffset * 60 * 1000);
-            }
-            else {
-                forcedTzo = parts.timeZoneOffset;
-            }
-        }
-        return { marker, isTimeUnspecified: parts.isTimeUnspecified, forcedTzo };
-    }
-    // Accessors
-    getYear(marker) {
-        return this.calendarSystem.getMarkerYear(marker);
-    }
-    getMonth(marker) {
-        return this.calendarSystem.getMarkerMonth(marker);
-    }
-    getDay(marker) {
-        return this.calendarSystem.getMarkerDay(marker);
-    }
-    // Adding / Subtracting
-    add(marker, dur) {
-        let a = this.calendarSystem.markerToArray(marker);
-        a[0] += dur.years;
-        a[1] += dur.months;
-        a[2] += dur.days;
-        a[6] += dur.milliseconds;
-        return this.calendarSystem.arrayToMarker(a);
-    }
-    subtract(marker, dur) {
-        let a = this.calendarSystem.markerToArray(marker);
-        a[0] -= dur.years;
-        a[1] -= dur.months;
-        a[2] -= dur.days;
-        a[6] -= dur.milliseconds;
-        return this.calendarSystem.arrayToMarker(a);
-    }
-    addYears(marker, n) {
-        let a = this.calendarSystem.markerToArray(marker);
-        a[0] += n;
-        return this.calendarSystem.arrayToMarker(a);
-    }
-    addMonths(marker, n) {
-        let a = this.calendarSystem.markerToArray(marker);
-        a[1] += n;
-        return this.calendarSystem.arrayToMarker(a);
-    }
-    // Diffing Whole Units
-    diffWholeYears(m0, m1) {
-        let { calendarSystem } = this;
-        if (timeAsMs(m0) === timeAsMs(m1) &&
-            calendarSystem.getMarkerDay(m0) === calendarSystem.getMarkerDay(m1) &&
-            calendarSystem.getMarkerMonth(m0) === calendarSystem.getMarkerMonth(m1)) {
-            return calendarSystem.getMarkerYear(m1) - calendarSystem.getMarkerYear(m0);
-        }
-        return null;
-    }
-    diffWholeMonths(m0, m1) {
-        let { calendarSystem } = this;
-        if (timeAsMs(m0) === timeAsMs(m1) &&
-            calendarSystem.getMarkerDay(m0) === calendarSystem.getMarkerDay(m1)) {
-            return (calendarSystem.getMarkerMonth(m1) - calendarSystem.getMarkerMonth(m0)) +
-                (calendarSystem.getMarkerYear(m1) - calendarSystem.getMarkerYear(m0)) * 12;
-        }
-        return null;
-    }
-    // Range / Duration
-    greatestWholeUnit(m0, m1) {
-        let n = this.diffWholeYears(m0, m1);
-        if (n !== null) {
-            return { unit: 'year', value: n };
-        }
-        n = this.diffWholeMonths(m0, m1);
-        if (n !== null) {
-            return { unit: 'month', value: n };
-        }
-        n = diffWholeWeeks(m0, m1);
-        if (n !== null) {
-            return { unit: 'week', value: n };
-        }
-        n = diffWholeDays(m0, m1);
-        if (n !== null) {
-            return { unit: 'day', value: n };
-        }
-        n = diffHours(m0, m1);
-        if (isInt(n)) {
-            return { unit: 'hour', value: n };
-        }
-        n = diffMinutes(m0, m1);
-        if (isInt(n)) {
-            return { unit: 'minute', value: n };
-        }
-        n = diffSeconds(m0, m1);
-        if (isInt(n)) {
-            return { unit: 'second', value: n };
-        }
-        return { unit: 'millisecond', value: m1.valueOf() - m0.valueOf() };
-    }
-    countDurationsBetween(m0, m1, d) {
-        // TODO: can use greatestWholeUnit
-        let diff;
-        if (d.years) {
-            diff = this.diffWholeYears(m0, m1);
-            if (diff !== null) {
-                return diff / asRoughYears(d);
-            }
-        }
-        if (d.months) {
-            diff = this.diffWholeMonths(m0, m1);
-            if (diff !== null) {
-                return diff / asRoughMonths(d);
-            }
-        }
-        if (d.days) {
-            diff = diffWholeDays(m0, m1);
-            if (diff !== null) {
-                return diff / asRoughDays(d);
-            }
-        }
-        return (m1.valueOf() - m0.valueOf()) / asRoughMs(d);
-    }
-    // Start-Of
-    // these DON'T return zoned-dates. only UTC start-of dates
-    startOf(m, unit) {
-        if (unit === 'year') {
-            return this.startOfYear(m);
-        }
-        if (unit === 'month') {
-            return this.startOfMonth(m);
-        }
-        if (unit === 'week') {
-            return this.startOfWeek(m);
-        }
-        if (unit === 'day') {
-            return startOfDay(m);
-        }
-        if (unit === 'hour') {
-            return startOfHour(m);
-        }
-        if (unit === 'minute') {
-            return startOfMinute(m);
-        }
-        if (unit === 'second') {
-            return startOfSecond(m);
-        }
-        return null;
-    }
-    startOfYear(m) {
-        return this.calendarSystem.arrayToMarker([
-            this.calendarSystem.getMarkerYear(m),
-        ]);
-    }
-    startOfMonth(m) {
-        return this.calendarSystem.arrayToMarker([
-            this.calendarSystem.getMarkerYear(m),
-            this.calendarSystem.getMarkerMonth(m),
-        ]);
-    }
-    startOfWeek(m) {
-        return this.calendarSystem.arrayToMarker([
-            this.calendarSystem.getMarkerYear(m),
-            this.calendarSystem.getMarkerMonth(m),
-            m.getUTCDate() - ((m.getUTCDay() - this.weekDow + 7) % 7),
-        ]);
-    }
-    // Week Number
-    computeWeekNumber(marker) {
-        if (this.weekNumberFunc) {
-            return this.weekNumberFunc(this.toDate(marker));
-        }
-        return weekOfYear(marker, this.weekDow, this.weekDoy);
-    }
-    // TODO: choke on timeZoneName: long
-    format(marker, formatter, dateOptions = {}) {
-        return formatter.format({
-            marker,
-            timeZoneOffset: dateOptions.forcedTzo != null ?
-                dateOptions.forcedTzo :
-                this.offsetForMarker(marker),
-        }, this);
-    }
-    // Unlike format(), returns plain string!
-    formatRange(start, end, formatter, dateOptions = {}) {
-        if (dateOptions.isEndExclusive) {
-            end = addMs(end, -1);
-        }
-        return formatter.formatRange({
-            marker: start,
-            timeZoneOffset: dateOptions.forcedStartTzo != null ?
-                dateOptions.forcedStartTzo :
-                this.offsetForMarker(start),
-        }, {
-            marker: end,
-            timeZoneOffset: dateOptions.forcedEndTzo != null ?
-                dateOptions.forcedEndTzo :
-                this.offsetForMarker(end),
-        }, this, dateOptions.defaultSeparator);
-    }
-    /*
-    DUMB: the omitTime arg is dumb. if we omit the time, we want to omit the timezone offset. and if we do that,
-    might as well use buildIsoString or some other util directly
-    */
-    formatIso(marker, extraOptions = {}) {
-        let timeZoneOffset = null;
-        if (!extraOptions.omitTimeZoneOffset) {
-            if (extraOptions.forcedTzo != null) {
-                timeZoneOffset = extraOptions.forcedTzo;
-            }
-            else {
-                timeZoneOffset = this.offsetForMarker(marker);
-            }
-        }
-        return buildIsoString(marker, timeZoneOffset, extraOptions.omitTime);
-    }
-    // TimeZone
-    timestampToMarker(ms) {
-        if (this.timeZone === 'local') {
-            return arrayToUtcDate(dateToLocalArray(new Date(ms)));
-        }
-        if (this.timeZone === 'UTC' || !this.namedTimeZoneImpl) {
-            return new Date(ms);
-        }
-        return arrayToUtcDate(this.namedTimeZoneImpl.timestampToArray(ms));
-    }
-    offsetForMarker(m) {
-        if (this.timeZone === 'local') {
-            return -arrayToLocalDate(dateToUtcArray(m)).getTimezoneOffset(); // convert "inverse" offset to "normal" offset
-        }
-        if (this.timeZone === 'UTC') {
-            return 0;
-        }
-        if (this.namedTimeZoneImpl) {
-            return this.namedTimeZoneImpl.offsetForArray(dateToUtcArray(m));
-        }
-        return null;
-    }
-    // Conversion
-    toDate(m, forcedTzo) {
-        if (this.timeZone === 'local') {
-            return arrayToLocalDate(dateToUtcArray(m));
-        }
-        if (this.timeZone === 'UTC') {
-            return new Date(m.valueOf()); // make sure it's a copy
-        }
-        if (!this.namedTimeZoneImpl) {
-            return new Date(m.valueOf() - (forcedTzo || 0));
-        }
-        return new Date(m.valueOf() -
-            this.namedTimeZoneImpl.offsetForArray(dateToUtcArray(m)) * 1000 * 60);
-    }
-}
-
-/*
-TODO: fix the terminology of "formatter" vs "formatting func"
-*/
-/*
-At the time of instantiation, this object does not know which cmd-formatting system it will use.
-It receives this at the time of formatting, as a setting.
-*/
-class CmdFormatter {
-    constructor(cmdStr) {
-        this.cmdStr = cmdStr;
-    }
-    format(date, context, betterDefaultSeparator) {
-        const res = context.cmdFormatter(this.cmdStr, createVerboseFormattingArg(date, null, context, betterDefaultSeparator));
-        // array of parts?
-        if (typeof res === 'object') {
-            return [joinDateTimeFormatParts(res), res];
-        }
-        // otherwise, just a string
-        return [res, [{ type: 'literal', value: res }]];
-    }
-    // Unlike format(), returns plain string!
-    formatRange(start, end, context, betterDefaultSeparator) {
-        const res = context.cmdFormatter(this.cmdStr, createVerboseFormattingArg(start, end, context, betterDefaultSeparator));
-        // array of parts?
-        if (typeof res === 'object') {
-            return joinDateTimeFormatParts(res);
-        }
-        // otherwise, just a string
-        return res;
-    }
-}
-
-class FuncFormatter {
-    constructor(func) {
-        this.func = func;
-    }
-    format(date, context, betterDefaultSeparator) {
-        const str = this.func(createVerboseFormattingArg(date, null, context, betterDefaultSeparator));
-        return [
-            str,
-            // HACK. In future versions, allow func-formatters to return parts?
-            [{ type: 'literal', value: str }],
-        ];
-    }
-    // Unlike format(), returns plain string!
-    formatRange(start, end, context, betterDefaultSeparator) {
-        return this.func(createVerboseFormattingArg(start, end, context, betterDefaultSeparator));
-    }
-}
-
-class NamedTimeZoneImpl {
-    constructor(timeZoneName) {
-        this.timeZoneName = timeZoneName;
-    }
-}
-
-exports.CmdFormatter = CmdFormatter;
-exports.DateEnv = DateEnv;
-exports.FuncFormatter = FuncFormatter;
-exports.NamedTimeZoneImpl = NamedTimeZoneImpl;
-exports.addDays = addDays;
-exports.addDurations = addDurations;
-exports.addMs = addMs;
-exports.addWeeks = addWeeks;
-exports.arrayToLocalDate = arrayToLocalDate;
-exports.arrayToUtcDate = arrayToUtcDate;
-exports.asCleanDays = asCleanDays;
-exports.asRoughDays = asRoughDays;
-exports.asRoughHours = asRoughHours;
-exports.asRoughMinutes = asRoughMinutes;
-exports.asRoughMonths = asRoughMonths;
-exports.asRoughMs = asRoughMs;
-exports.asRoughSeconds = asRoughSeconds;
-exports.asRoughYears = asRoughYears;
-exports.buildIsoString = buildIsoString;
-exports.constrainMarkerToRange = constrainMarkerToRange;
-exports.createCalendarSystem = createCalendarSystem;
-exports.createDuration = createDuration;
-exports.createVerboseFormattingArg = createVerboseFormattingArg;
-exports.dateToLocalArray = dateToLocalArray;
-exports.dateToUtcArray = dateToUtcArray;
-exports.diffDayAndTime = diffDayAndTime;
-exports.diffDays = diffDays;
-exports.diffHours = diffHours;
-exports.diffMinutes = diffMinutes;
-exports.diffSeconds = diffSeconds;
-exports.diffWeeks = diffWeeks;
-exports.diffWholeDays = diffWholeDays;
-exports.diffWholeWeeks = diffWholeWeeks;
-exports.durationsEqual = durationsEqual;
-exports.expandZonedMarker = expandZonedMarker;
-exports.formatDayString = formatDayString;
-exports.formatIsoMonthStr = formatIsoMonthStr;
-exports.formatIsoTimeString = formatIsoTimeString;
-exports.formatTimeZoneOffset = formatTimeZoneOffset;
-exports.greatestDurationDenominator = greatestDurationDenominator;
-exports.intersectRanges = intersectRanges;
-exports.invertRanges = invertRanges;
-exports.isInt = isInt;
-exports.isValidDate = isValidDate;
-exports.joinDateTimeFormatParts = joinDateTimeFormatParts;
-exports.multiplyDuration = multiplyDuration;
-exports.padStart = padStart;
-exports.parse = parse;
-exports.parseRange = parseRange;
-exports.rangeContainsMarker = rangeContainsMarker;
-exports.rangeContainsRange = rangeContainsRange;
-exports.rangesEqual = rangesEqual;
-exports.rangesIntersect = rangesIntersect;
-exports.registerCalendarSystem = registerCalendarSystem;
-exports.startOfDay = startOfDay;
-exports.startOfHour = startOfHour;
-exports.startOfMinute = startOfMinute;
-exports.startOfSecond = startOfSecond;
-exports.subtractDurations = subtractDurations;
-exports.timeAsMs = timeAsMs;
-exports.trimEnd = trimEnd;
-exports.weekOfYear = weekOfYear;
-exports.wholeDivideDurations = wholeDivideDurations;