@full-ui/headless-calendar 7.0.0-beta.5

package/cjs/index.cjs

@@ -0,0 +1,1011 @@
+'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;