@elastic/charts 57.0.1 → 58.1.0

package/dist/chart_types/xy_chart/axes/timeslip/continuous_time_rasters.js

@@ -1,82 +1,8 @@
 "use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __values = (this && this.__values) || function(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.continuousTimeRasters = exports.unitIntervalWidth = void 0;
-var cached_chrono_1 = require("./chrono/cached_chrono");
-var chrono_1 = require("./chrono/chrono");
+const cached_chrono_1 = require("./chrono/cached_chrono");
+const chrono_1 = require("./chrono/chrono");
 exports.unitIntervalWidth = {
     year: 365.25 * 24 * 60 * 60,
     month: (365.25 * 24 * 60 * 60) / 12,
@@ -88,100 +14,47 @@ exports.unitIntervalWidth = {
     millisecond: 0.001,
     one: 1,
 };
-var millisecondIntervals = function (rasterMs) {
-    return function (domainFrom, domainTo) {
-        var t, minimum, supremum;
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    t = Math.floor((domainFrom * 1000) / rasterMs);
-                    _a.label = 1;
-                case 1:
-                    if (!(t < Math.ceil((domainTo * 1000) / rasterMs))) return [3, 4];
-                    minimum = (t * rasterMs) / 1000;
-                    supremum = minimum + rasterMs / 1000;
-                    return [4, {
-                            minimum: minimum,
-                            supremum: supremum,
-                            labelSupremum: supremum,
-                        }];
-                case 2:
-                    _a.sent();
-                    _a.label = 3;
-                case 3:
-                    t++;
-                    return [3, 1];
-                case 4: return [2];
-            }
-        });
-    };
+const millisecondIntervals = (rasterMs) => function* (domainFrom, domainTo) {
+    for (let t = Math.floor((domainFrom * 1000) / rasterMs); t < Math.ceil((domainTo * 1000) / rasterMs); t++) {
+        const minimum = (t * rasterMs) / 1000;
+        const supremum = minimum + rasterMs / 1000;
+        yield {
+            minimum,
+            supremum,
+            labelSupremum: supremum,
+        };
+    }
 };
-var monthBasedIntervals = function (years, timeZone, unitMultiplier) {
-    return function (domainFrom, domainTo) {
-        var _a, _b, year, month, timePoint, binStart, binEnd, days, e_1_1;
-        var e_1, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    _d.trys.push([0, 7, 8, 9]);
-                    _a = __values(years.intervals(domainFrom, domainTo)), _b = _a.next();
-                    _d.label = 1;
-                case 1:
-                    if (!!_b.done) return [3, 6];
-                    year = _b.value.year;
-                    month = 1;
-                    _d.label = 2;
-                case 2:
-                    if (!(month <= 12)) return [3, 5];
-                    timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)({ timeZone: timeZone, year: year, month: month, day: 1 });
-                    binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
-                    binEnd = (0, cached_chrono_1.cachedZonedDateTimeFrom)({
-                        timeZone: timeZone,
-                        year: month <= 12 - unitMultiplier ? year : year + 1,
-                        month: ((month + unitMultiplier - 1) % 12) + 1,
-                        day: 1,
-                    })[cached_chrono_1.TimeProp.EpochSeconds];
-                    days = (0, chrono_1.epochDaysInMonth)(timeZone, binStart);
-                    return [4, {
-                            year: year,
-                            month: month,
-                            days: days,
-                            minimum: binStart,
-                            supremum: binEnd,
-                            labelSupremum: binEnd,
-                        }];
-                case 3:
-                    _d.sent();
-                    _d.label = 4;
-                case 4:
-                    month += unitMultiplier;
-                    return [3, 2];
-                case 5:
-                    _b = _a.next();
-                    return [3, 1];
-                case 6: return [3, 9];
-                case 7:
-                    e_1_1 = _d.sent();
-                    e_1 = { error: e_1_1 };
-                    return [3, 9];
-                case 8:
-                    try {
-                        if (_b && !_b.done && (_c = _a.return)) _c.call(_a);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                    return [7];
-                case 9: return [2];
-            }
-        });
-    };
+const monthBasedIntervals = (years, timeZone, unitMultiplier) => function* (domainFrom, domainTo) {
+    for (const { year } of years.intervals(domainFrom, domainTo)) {
+        for (let month = 1; month <= 12; month += unitMultiplier) {
+            const timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)({ timeZone, year, month, day: 1 });
+            const binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
+            const binEnd = (0, cached_chrono_1.cachedZonedDateTimeFrom)({
+                timeZone,
+                year: month <= 12 - unitMultiplier ? year : year + 1,
+                month: ((month + unitMultiplier - 1) % 12) + 1,
+                day: 1,
+            })[cached_chrono_1.TimeProp.EpochSeconds];
+            const days = (0, chrono_1.epochDaysInMonth)(timeZone, binStart);
+            yield {
+                year,
+                month,
+                days,
+                minimum: binStart,
+                supremum: binEnd,
+                labelSupremum: binEnd,
+            };
+        }
+    }
 };
-var hourCycle = 'h23';
-var hourFormat = {
+const hourCycle = 'h23';
+const hourFormat = {
     hour: '2-digit',
     minute: '2-digit',
-    hourCycle: hourCycle,
+    hourCycle,
 };
-var englishOrdinalEndings = {
+const englishOrdinalEndings = {
     zero: 'th',
     one: 'st',
     two: 'nd',
@@ -189,361 +62,393 @@ var englishOrdinalEndings = {
     many: 'th',
     other: 'th',
 };
-var englishPluralRules = new Intl.PluralRules('en-US', { type: 'ordinal' });
-var englishOrdinalEnding = function (signedNumber) { return englishOrdinalEndings[englishPluralRules.select(signedNumber)]; };
-var continuousTimeRasters = function (_a, timeZone) {
-    var minimumTickPixelDistance = _a.minimumTickPixelDistance, locale = _a.locale;
-    var minorDayBaseFormat = new Intl.DateTimeFormat(locale, { day: 'numeric', timeZone: timeZone }).format;
-    var minorDayFormat = function (d) {
-        var numberString = minorDayBaseFormat(d);
-        var number = Number.parseInt(numberString, 10);
-        return locale.substr(0, 2) === 'en' ? "".concat(numberString).concat(englishOrdinalEnding(number)) : numberString;
-    };
-    var detailedDayFormat = new Intl.DateTimeFormat(locale, {
+const englishPluralRules = new Intl.PluralRules('en-US', { type: 'ordinal' });
+const englishOrdinalEnding = (signedNumber) => englishOrdinalEndings[englishPluralRules.select(signedNumber)];
+const continuousTimeRasters = ({ minimumTickPixelDistance, locale }, timeZone) => {
+    const minorDayBaseFormat = new Intl.DateTimeFormat(locale, { day: 'numeric', timeZone }).format;
+    const minorDayFormat = (d) => {
+        const numberString = minorDayBaseFormat(d);
+        const number = Number.parseInt(numberString, 10);
+        return locale.substr(0, 2) === 'en' ? `${numberString}${englishOrdinalEnding(number)}` : numberString;
+    };
+    const detailedDayFormat = new Intl.DateTimeFormat(locale, {
         year: 'numeric',
         month: 'long',
         day: 'numeric',
-        timeZone: timeZone,
+        timeZone,
     }).format;
-    var detailedHourFormatBase = new Intl.DateTimeFormat(locale, __assign(__assign({ year: 'numeric', month: 'long', day: 'numeric' }, hourFormat), { timeZone: timeZone })).format;
-    var detailedHourFormat = function (d) { return "".concat(detailedHourFormatBase(d), "h"); };
-    var years = {
+    const detailedHourFormatBase = new Intl.DateTimeFormat(locale, {
+        year: 'numeric',
+        month: 'long',
+        day: 'numeric',
+        ...hourFormat,
+        timeZone,
+    }).format;
+    const detailedHourFormat = (d) => `${detailedHourFormatBase(d)}h`;
+    const years = {
         unit: 'year',
         unitMultiplier: 1,
         labeled: true,
         minimumTickPixelDistance: minimumTickPixelDistance * 1.5,
-        intervals: function (domainFrom, domainTo) {
-            var fromYear, toYear, year, timePoint, binStart, binEnd;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        fromYear = (0, chrono_1.epochInSecondsToYear)(timeZone, domainFrom);
-                        toYear = (0, chrono_1.epochInSecondsToYear)(timeZone, domainTo);
-                        year = fromYear;
-                        _a.label = 1;
-                    case 1:
-                        if (!(year <= toYear)) return [3, 4];
-                        timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)({ timeZone: timeZone, year: year, month: 1, day: 1 });
-                        binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
-                        binEnd = (0, cached_chrono_1.cachedZonedDateTimeFrom)({
-                            timeZone: timeZone,
-                            year: year + 1,
-                            month: 1,
-                            day: 1,
-                        })[cached_chrono_1.TimeProp.EpochSeconds];
-                        return [4, {
-                                year: year,
-                                minimum: binStart,
-                                supremum: binEnd,
-                                labelSupremum: binEnd,
-                            }];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        year++;
-                        return [3, 1];
-                    case 4: return [2];
-                }
-            });
+        intervals: function* (domainFrom, domainTo) {
+            const fromYear = (0, chrono_1.epochInSecondsToYear)(timeZone, domainFrom);
+            const toYear = (0, chrono_1.epochInSecondsToYear)(timeZone, domainTo);
+            for (let year = fromYear; year <= toYear; year++) {
+                const timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)({ timeZone, year, month: 1, day: 1 });
+                const binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
+                const binEnd = (0, cached_chrono_1.cachedZonedDateTimeFrom)({
+                    timeZone,
+                    year: year + 1,
+                    month: 1,
+                    day: 1,
+                })[cached_chrono_1.TimeProp.EpochSeconds];
+                yield {
+                    year,
+                    minimum: binStart,
+                    supremum: binEnd,
+                    labelSupremum: binEnd,
+                };
+            }
         },
-        detailedLabelFormat: new Intl.DateTimeFormat(locale, { year: 'numeric', timeZone: timeZone }).format,
-        minorTickLabelFormat: new Intl.DateTimeFormat(locale, { year: 'numeric', timeZone: timeZone }).format,
+        detailedLabelFormat: new Intl.DateTimeFormat(locale, { year: 'numeric', timeZone }).format,
+        minorTickLabelFormat: new Intl.DateTimeFormat(locale, { year: 'numeric', timeZone }).format,
     };
-    var unlabeledGridMinimumPixelDistance = minimumTickPixelDistance / 1.618;
-    var yearsUnlabelled = __assign(__assign({}, years), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var decades = {
+    const unlabeledGridMinimumPixelDistance = minimumTickPixelDistance / 1.618;
+    const yearsUnlabelled = {
+        ...years,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const decades = {
         unit: 'year',
         unitMultiplier: 10,
         labeled: true,
         minimumTickPixelDistance: minimumTickPixelDistance * 1.5,
-        intervals: function (domainFrom, domainTo) {
-            var fromYear, toYear, year, timePoint, binStart, binEnd;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        fromYear = (0, chrono_1.epochInSecondsToYear)(timeZone, domainFrom);
-                        toYear = (0, chrono_1.epochInSecondsToYear)(timeZone, domainTo);
-                        year = Math.floor(fromYear / 10) * 10;
-                        _a.label = 1;
-                    case 1:
-                        if (!(year <= Math.ceil(toYear / 10) * 10)) return [3, 4];
-                        timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)({ timeZone: timeZone, year: year, month: 1, day: 1 });
-                        binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
-                        binEnd = (0, cached_chrono_1.cachedZonedDateTimeFrom)({
-                            timeZone: timeZone,
-                            year: year + 10,
-                            month: 1,
-                            day: 1,
-                        })[cached_chrono_1.TimeProp.EpochSeconds];
-                        return [4, {
-                                year: year,
-                                minimum: binStart,
-                                supremum: binEnd,
-                                labelSupremum: binEnd,
-                            }];
-                    case 2:
-                        _a.sent();
-                        _a.label = 3;
-                    case 3:
-                        year += 10;
-                        return [3, 1];
-                    case 4: return [2];
-                }
-            });
+        intervals: function* (domainFrom, domainTo) {
+            const fromYear = (0, chrono_1.epochInSecondsToYear)(timeZone, domainFrom);
+            const toYear = (0, chrono_1.epochInSecondsToYear)(timeZone, domainTo);
+            for (let year = Math.floor(fromYear / 10) * 10; year <= Math.ceil(toYear / 10) * 10; year += 10) {
+                const timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)({ timeZone, year, month: 1, day: 1 });
+                const binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
+                const binEnd = (0, cached_chrono_1.cachedZonedDateTimeFrom)({
+                    timeZone,
+                    year: year + 10,
+                    month: 1,
+                    day: 1,
+                })[cached_chrono_1.TimeProp.EpochSeconds];
+                yield {
+                    year,
+                    minimum: binStart,
+                    supremum: binEnd,
+                    labelSupremum: binEnd,
+                };
+            }
         },
-        detailedLabelFormat: new Intl.DateTimeFormat(locale, { year: 'numeric', timeZone: timeZone }).format,
-        minorTickLabelFormat: new Intl.DateTimeFormat(locale, { year: 'numeric', timeZone: timeZone }).format,
+        detailedLabelFormat: new Intl.DateTimeFormat(locale, { year: 'numeric', timeZone }).format,
+        minorTickLabelFormat: new Intl.DateTimeFormat(locale, { year: 'numeric', timeZone }).format,
     };
-    var decadesUnlabelled = __assign(__assign({}, decades), { labeled: false, minimumTickPixelDistance: 1 });
-    var months = {
+    const decadesUnlabelled = {
+        ...decades,
+        labeled: false,
+        minimumTickPixelDistance: 1,
+    };
+    const months = {
         unit: 'month',
         unitMultiplier: 1,
         labeled: true,
         minimumTickPixelDistance: minimumTickPixelDistance * 3.6,
         intervals: monthBasedIntervals(years, timeZone, 1),
-        detailedLabelFormat: new Intl.DateTimeFormat(locale, { year: 'numeric', month: 'long', timeZone: timeZone }).format,
-        minorTickLabelFormat: new Intl.DateTimeFormat(locale, { month: 'long', timeZone: timeZone }).format,
+        detailedLabelFormat: new Intl.DateTimeFormat(locale, { year: 'numeric', month: 'long', timeZone }).format,
+        minorTickLabelFormat: new Intl.DateTimeFormat(locale, { month: 'long', timeZone }).format,
+    };
+    const shortMonths = {
+        ...months,
+        minorTickLabelFormat: new Intl.DateTimeFormat(locale, { month: 'short', timeZone }).format,
+        minimumTickPixelDistance: minimumTickPixelDistance * 2,
+    };
+    const quarters = {
+        ...shortMonths,
+        unitMultiplier: 3,
+        intervals: monthBasedIntervals(years, timeZone, 3),
     };
-    var shortMonths = __assign(__assign({}, months), { minorTickLabelFormat: new Intl.DateTimeFormat(locale, { month: 'short', timeZone: timeZone }).format, minimumTickPixelDistance: minimumTickPixelDistance * 2 });
-    var quarters = __assign(__assign({}, shortMonths), { unitMultiplier: 3, intervals: monthBasedIntervals(years, timeZone, 3) });
-    var quartersUnlabelled = __assign(__assign({}, quarters), { minimumTickPixelDistance: unlabeledGridMinimumPixelDistance, labeled: false });
-    var days = {
+    const quartersUnlabelled = {
+        ...quarters,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+        labeled: false,
+    };
+    const days = {
         unit: 'day',
         unitMultiplier: 1,
         labeled: true,
         minimumTickPixelDistance: minimumTickPixelDistance * 1.5,
-        intervals: function (domainFrom, domainTo) {
-            var _a, _b, _c, year, month, dayOfMonth, temporalArgs, timePoint, dayOfWeek, binStart, binEnd, e_2_1;
-            var e_2, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        _e.trys.push([0, 7, 8, 9]);
-                        _a = __values(months.intervals(domainFrom, domainTo)), _b = _a.next();
-                        _e.label = 1;
-                    case 1:
-                        if (!!_b.done) return [3, 6];
-                        _c = _b.value, year = _c.year, month = _c.month;
-                        dayOfMonth = 1;
-                        _e.label = 2;
-                    case 2:
-                        if (!(dayOfMonth <= 31)) return [3, 5];
-                        temporalArgs = {
-                            timeZone: timeZone,
-                            year: year,
-                            month: month,
-                            day: dayOfMonth,
+        intervals: function* (domainFrom, domainTo) {
+            for (const { year, month } of months.intervals(domainFrom, domainTo)) {
+                for (let dayOfMonth = 1; dayOfMonth <= 31; dayOfMonth++) {
+                    const temporalArgs = {
+                        timeZone,
+                        year,
+                        month,
+                        day: dayOfMonth,
+                    };
+                    const timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)(temporalArgs);
+                    const dayOfWeek = timePoint[cached_chrono_1.TimeProp.DayOfWeek];
+                    const binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
+                    const binEnd = (0, cached_chrono_1.cachedTimeDelta)(temporalArgs, 'days', 1);
+                    if (Number.isFinite(binStart) && Number.isFinite(binEnd))
+                        yield {
+                            year,
+                            month,
+                            dayOfMonth,
+                            dayOfWeek,
+                            minimum: binStart,
+                            supremum: binEnd,
+                            labelSupremum: binEnd,
                         };
-                        timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)(temporalArgs);
-                        dayOfWeek = timePoint[cached_chrono_1.TimeProp.DayOfWeek];
-                        binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
-                        binEnd = (0, cached_chrono_1.cachedTimeDelta)(temporalArgs, 'days', 1);
-                        if (!(Number.isFinite(binStart) && Number.isFinite(binEnd))) return [3, 4];
-                        return [4, {
-                                year: year,
-                                month: month,
-                                dayOfMonth: dayOfMonth,
-                                dayOfWeek: dayOfWeek,
-                                minimum: binStart,
-                                supremum: binEnd,
-                                labelSupremum: binEnd,
-                            }];
-                    case 3:
-                        _e.sent();
-                        _e.label = 4;
-                    case 4:
-                        dayOfMonth++;
-                        return [3, 2];
-                    case 5:
-                        _b = _a.next();
-                        return [3, 1];
-                    case 6: return [3, 9];
-                    case 7:
-                        e_2_1 = _e.sent();
-                        e_2 = { error: e_2_1 };
-                        return [3, 9];
-                    case 8:
-                        try {
-                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                        return [7];
-                    case 9: return [2];
                 }
-            });
+            }
         },
         detailedLabelFormat: detailedDayFormat,
         minorTickLabelFormat: minorDayFormat,
     };
-    var weekStartDays = {
+    const weekStartDays = {
         unit: 'week',
         unitMultiplier: 1,
         labeled: true,
         minimumTickPixelDistance: minimumTickPixelDistance * 1.5,
-        intervals: function (domainFrom, domainTo) {
-            var _a, _b, _c, year, month, daysInMonth, dayOfMonth, temporalArgs, timePoint, dayOfWeek, binStart, daysFromEnd, supremum, e_3_1;
-            var e_3, _d;
-            return __generator(this, function (_e) {
-                switch (_e.label) {
-                    case 0:
-                        _e.trys.push([0, 7, 8, 9]);
-                        _a = __values(months.intervals(domainFrom, domainTo)), _b = _a.next();
-                        _e.label = 1;
-                    case 1:
-                        if (!!_b.done) return [3, 6];
-                        _c = _b.value, year = _c.year, month = _c.month, daysInMonth = _c.days;
-                        dayOfMonth = 1;
-                        _e.label = 2;
-                    case 2:
-                        if (!(dayOfMonth <= 31)) return [3, 5];
-                        temporalArgs = { timeZone: timeZone, year: year, month: month, day: dayOfMonth };
-                        timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)(temporalArgs);
-                        dayOfWeek = timePoint[cached_chrono_1.TimeProp.DayOfWeek];
-                        if (dayOfWeek !== 1)
-                            return [3, 4];
-                        binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
-                        if (!Number.isFinite(binStart)) return [3, 4];
-                        daysFromEnd = daysInMonth - dayOfMonth + 1;
-                        supremum = (0, cached_chrono_1.cachedTimeDelta)(temporalArgs, 'days', 7);
-                        return [4, {
-                                dayOfMonth: dayOfMonth,
-                                minimum: binStart,
-                                supremum: supremum,
-                                labelSupremum: daysFromEnd < 7 ? (0, cached_chrono_1.cachedTimeDelta)(temporalArgs, 'days', daysFromEnd) : supremum,
-                            }];
-                    case 3:
-                        _e.sent();
-                        _e.label = 4;
-                    case 4:
-                        dayOfMonth++;
-                        return [3, 2];
-                    case 5:
-                        _b = _a.next();
-                        return [3, 1];
-                    case 6: return [3, 9];
-                    case 7:
-                        e_3_1 = _e.sent();
-                        e_3 = { error: e_3_1 };
-                        return [3, 9];
-                    case 8:
-                        try {
-                            if (_b && !_b.done && (_d = _a.return)) _d.call(_a);
-                        }
-                        finally { if (e_3) throw e_3.error; }
-                        return [7];
-                    case 9: return [2];
+        intervals: function* (domainFrom, domainTo) {
+            for (const { year, month, days: daysInMonth } of months.intervals(domainFrom, domainTo)) {
+                for (let dayOfMonth = 1; dayOfMonth <= 31; dayOfMonth++) {
+                    const temporalArgs = { timeZone, year, month, day: dayOfMonth };
+                    const timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)(temporalArgs);
+                    const dayOfWeek = timePoint[cached_chrono_1.TimeProp.DayOfWeek];
+                    if (dayOfWeek !== 1)
+                        continue;
+                    const binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
+                    if (Number.isFinite(binStart)) {
+                        const daysFromEnd = daysInMonth - dayOfMonth + 1;
+                        const supremum = (0, cached_chrono_1.cachedTimeDelta)(temporalArgs, 'days', 7);
+                        yield {
+                            dayOfMonth,
+                            minimum: binStart,
+                            supremum,
+                            labelSupremum: daysFromEnd < 7 ? (0, cached_chrono_1.cachedTimeDelta)(temporalArgs, 'days', daysFromEnd) : supremum,
+                        };
+                    }
                 }
-            });
+            }
         },
         minorTickLabelFormat: minorDayFormat,
         detailedLabelFormat: detailedDayFormat,
     };
-    var daysUnlabelled = __assign(__assign({}, days), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var weeksUnlabelled = __assign(__assign({}, weekStartDays), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var monthsUnlabelled = __assign(__assign({}, months), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var hhMmDistanceMultiplier = 1.8;
-    var hhMmSsDistanceMultiplier = 2.5;
-    var hours = {
+    const daysUnlabelled = {
+        ...days,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const weeksUnlabelled = {
+        ...weekStartDays,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const monthsUnlabelled = {
+        ...months,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const hhMmDistanceMultiplier = 1.8;
+    const hhMmSsDistanceMultiplier = 2.5;
+    const hours = {
         unit: 'hour',
         unitMultiplier: 1,
         labeled: true,
         minimumTickPixelDistance: hhMmDistanceMultiplier * minimumTickPixelDistance,
         intervals: millisecondIntervals(60 * 60 * 1000),
         detailedLabelFormat: detailedHourFormat,
-        minorTickLabelFormat: new Intl.DateTimeFormat(locale, __assign(__assign({}, hourFormat), { timeZone: timeZone })).format,
+        minorTickLabelFormat: new Intl.DateTimeFormat(locale, {
+            ...hourFormat,
+            timeZone,
+        }).format,
     };
-    var hoursUnlabelled = __assign(__assign({}, hours), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var sixHours = {
+    const hoursUnlabelled = {
+        ...hours,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const sixHours = {
         unit: 'hour',
         unitMultiplier: 6,
         labeled: true,
         minimumTickPixelDistance: 2 * minimumTickPixelDistance,
-        intervals: function (domainFrom, domainTo) {
-            return __spreadArray([], __read(days.intervals(domainFrom, domainTo)), false).flatMap(function (_a) {
-                var year = _a.year, month = _a.month, dayOfMonth = _a.dayOfMonth, dayOfWeek = _a.dayOfWeek;
-                return [0, 6, 12, 18].map(function (hour) {
-                    var temporalArgs = {
-                        timeZone: timeZone,
-                        year: year,
-                        month: month,
-                        day: dayOfMonth,
-                        hour: hour,
-                    };
-                    var timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)(temporalArgs);
-                    var binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
-                    var supremum = binStart + 6 * 60 * 60;
-                    return Number.isNaN(binStart)
-                        ? []
-                        : {
-                            dayOfMonth: dayOfMonth,
-                            dayOfWeek: dayOfWeek,
-                            hour: hour,
-                            year: year,
-                            month: month,
-                            minimum: binStart,
-                            supremum: supremum,
-                            labelSupremum: supremum,
-                        };
-                });
-            }).map(function (b, i, a) { var _a; return Object.assign(b, { supremum: i === a.length - 1 ? b.supremum : (_a = a[i + 1]) === null || _a === void 0 ? void 0 : _a.minimum }); });
-        },
-        minorTickLabelFormat: new Intl.DateTimeFormat(locale, __assign(__assign({}, hourFormat), { timeZone: timeZone })).format,
+        intervals: (domainFrom, domainTo) => [...days.intervals(domainFrom, domainTo)].flatMap(({ year, month, dayOfMonth, dayOfWeek }) => [0, 6, 12, 18].map((hour) => {
+            const temporalArgs = {
+                timeZone,
+                year,
+                month,
+                day: dayOfMonth,
+                hour,
+            };
+            const timePoint = (0, cached_chrono_1.cachedZonedDateTimeFrom)(temporalArgs);
+            const binStart = timePoint[cached_chrono_1.TimeProp.EpochSeconds];
+            const supremum = binStart + 6 * 60 * 60;
+            return Number.isNaN(binStart)
+                ? []
+                : {
+                    dayOfMonth,
+                    dayOfWeek,
+                    hour,
+                    year,
+                    month,
+                    minimum: binStart,
+                    supremum,
+                    labelSupremum: supremum,
+                };
+        })).map((b, i, a) => { var _a; return Object.assign(b, { supremum: i === a.length - 1 ? b.supremum : (_a = a[i + 1]) === null || _a === void 0 ? void 0 : _a.minimum }); }),
+        minorTickLabelFormat: new Intl.DateTimeFormat(locale, {
+            ...hourFormat,
+            timeZone,
+        }).format,
         detailedLabelFormat: detailedHourFormat,
     };
-    var sixHoursUnlabelled = __assign(__assign({}, sixHours), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var minutesFormatter = new Intl.DateTimeFormat(locale, { hour: '2-digit', minute: '2-digit', timeZone: timeZone, hourCycle: hourCycle });
-    var secondsFormatter = new Intl.DateTimeFormat(locale, {
+    const sixHoursUnlabelled = {
+        ...sixHours,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const minutesFormatter = new Intl.DateTimeFormat(locale, { hour: '2-digit', minute: '2-digit', timeZone, hourCycle });
+    const secondsFormatter = new Intl.DateTimeFormat(locale, {
         hour: '2-digit',
         minute: '2-digit',
         second: '2-digit',
-        timeZone: timeZone,
-        hourCycle: hourCycle,
+        timeZone,
+        hourCycle,
     });
-    var minutes = {
+    const minutes = {
         unit: 'minute',
         unitMultiplier: 1,
         labeled: true,
         minimumTickPixelDistance: hhMmDistanceMultiplier * minimumTickPixelDistance,
         intervals: millisecondIntervals(60 * 1000),
-        detailedLabelFormat: new Intl.DateTimeFormat(locale, __assign(__assign({ year: 'numeric', month: 'long', day: 'numeric' }, hourFormat), { minute: 'numeric', timeZone: timeZone })).format,
-        minorTickLabelFormat: function (d) { return "".concat(minutesFormatter.format(d)); },
-    };
-    var quarterHours = __assign(__assign({}, minutes), { unitMultiplier: 15, labeled: true, intervals: millisecondIntervals(15 * 60 * 1000) });
-    var quarterHoursUnlabelled = __assign(__assign({}, quarterHours), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var fiveMinutes = __assign(__assign({}, minutes), { unitMultiplier: 5, labeled: true, intervals: millisecondIntervals(5 * 60 * 1000) });
-    var fiveMinutesUnlabelled = __assign(__assign({}, fiveMinutes), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var minutesUnlabelled = __assign(__assign({}, minutes), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var seconds = {
+        detailedLabelFormat: new Intl.DateTimeFormat(locale, {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+            ...hourFormat,
+            minute: 'numeric',
+            timeZone,
+        }).format,
+        minorTickLabelFormat: (d) => `${minutesFormatter.format(d)}`,
+    };
+    const quarterHours = {
+        ...minutes,
+        unitMultiplier: 15,
+        labeled: true,
+        intervals: millisecondIntervals(15 * 60 * 1000),
+    };
+    const quarterHoursUnlabelled = {
+        ...quarterHours,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const fiveMinutes = {
+        ...minutes,
+        unitMultiplier: 5,
+        labeled: true,
+        intervals: millisecondIntervals(5 * 60 * 1000),
+    };
+    const fiveMinutesUnlabelled = {
+        ...fiveMinutes,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const minutesUnlabelled = {
+        ...minutes,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const seconds = {
         unit: 'second',
         unitMultiplier: 1,
         labeled: true,
         minimumTickPixelDistance: hhMmSsDistanceMultiplier * minimumTickPixelDistance,
         intervals: millisecondIntervals(1000),
-        detailedLabelFormat: new Intl.DateTimeFormat(locale, __assign(__assign({ year: 'numeric', month: 'long', day: 'numeric' }, hourFormat), { minute: 'numeric', second: 'numeric', timeZone: timeZone })).format,
-        minorTickLabelFormat: function (d) { return "".concat(secondsFormatter.format(d).padStart(2, '0')); },
-    };
-    var quarterMinutes = __assign(__assign({}, seconds), { unitMultiplier: 15, labeled: true, intervals: millisecondIntervals(15 * 1000) });
-    var quarterMinutesUnlabelled = __assign(__assign({}, quarterMinutes), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var fiveSeconds = __assign(__assign({}, seconds), { unitMultiplier: 5, labeled: true, intervals: millisecondIntervals(5 * 1000) });
-    var fiveSecondsUnlabelled = __assign(__assign({}, fiveSeconds), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var secondsUnlabelled = __assign(__assign({}, seconds), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var millisecondDistanceMultiplier = 1.8;
-    var milliseconds = {
+        detailedLabelFormat: new Intl.DateTimeFormat(locale, {
+            year: 'numeric',
+            month: 'long',
+            day: 'numeric',
+            ...hourFormat,
+            minute: 'numeric',
+            second: 'numeric',
+            timeZone,
+        }).format,
+        minorTickLabelFormat: (d) => `${secondsFormatter.format(d).padStart(2, '0')}`,
+    };
+    const quarterMinutes = {
+        ...seconds,
+        unitMultiplier: 15,
+        labeled: true,
+        intervals: millisecondIntervals(15 * 1000),
+    };
+    const quarterMinutesUnlabelled = {
+        ...quarterMinutes,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const fiveSeconds = {
+        ...seconds,
+        unitMultiplier: 5,
+        labeled: true,
+        intervals: millisecondIntervals(5 * 1000),
+    };
+    const fiveSecondsUnlabelled = {
+        ...fiveSeconds,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const secondsUnlabelled = {
+        ...seconds,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const millisecondDistanceMultiplier = 1.8;
+    const milliseconds = {
         unit: 'millisecond',
         unitMultiplier: 1,
         labeled: true,
         minimumTickPixelDistance: minimumTickPixelDistance * millisecondDistanceMultiplier,
         intervals: millisecondIntervals(1),
-        minorTickLabelFormat: function (d) { return "".concat(d % 1000, "ms"); },
-        detailedLabelFormat: function (d) { return "".concat(d % 1000, "ms"); },
-    };
-    var tenMilliseconds = __assign(__assign({}, milliseconds), { unitMultiplier: 10, labeled: true, minimumTickPixelDistance: minimumTickPixelDistance * millisecondDistanceMultiplier, intervals: millisecondIntervals(10) });
-    var hundredMilliseconds = __assign(__assign({}, milliseconds), { unitMultiplier: 100, labeled: true, minimumTickPixelDistance: minimumTickPixelDistance * millisecondDistanceMultiplier, intervals: millisecondIntervals(100) });
-    var millisecondsUnlabelled = __assign(__assign({}, milliseconds), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var tenMillisecondsUnlabelled = __assign(__assign({}, tenMilliseconds), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var hundredMillisecondsUnlabelled = __assign(__assign({}, hundredMilliseconds), { labeled: false, minimumTickPixelDistance: unlabeledGridMinimumPixelDistance });
-    var allRasters = [
+        minorTickLabelFormat: (d) => `${d % 1000}ms`,
+        detailedLabelFormat: (d) => `${d % 1000}ms`,
+    };
+    const tenMilliseconds = {
+        ...milliseconds,
+        unitMultiplier: 10,
+        labeled: true,
+        minimumTickPixelDistance: minimumTickPixelDistance * millisecondDistanceMultiplier,
+        intervals: millisecondIntervals(10),
+    };
+    const hundredMilliseconds = {
+        ...milliseconds,
+        unitMultiplier: 100,
+        labeled: true,
+        minimumTickPixelDistance: minimumTickPixelDistance * millisecondDistanceMultiplier,
+        intervals: millisecondIntervals(100),
+    };
+    const millisecondsUnlabelled = {
+        ...milliseconds,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const tenMillisecondsUnlabelled = {
+        ...tenMilliseconds,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const hundredMillisecondsUnlabelled = {
+        ...hundredMilliseconds,
+        labeled: false,
+        minimumTickPixelDistance: unlabeledGridMinimumPixelDistance,
+    };
+    const allRasters = [
         decades,
         yearsUnlabelled,
         years,
@@ -579,7 +484,7 @@ var continuousTimeRasters = function (_a, timeZone) {
         millisecondsUnlabelled,
         milliseconds,
     ];
-    var replacements = [
+    const replacements = [
         [decadesUnlabelled, new Map([])],
         [decades, new Map([[decadesUnlabelled, []]])],
         [
@@ -695,32 +600,20 @@ var continuousTimeRasters = function (_a, timeZone) {
             ]),
         ],
     ];
-    return function (filter) {
-        var e_4, _a;
-        var layers = new Set();
-        try {
-            for (var allRasters_1 = __values(allRasters), allRasters_1_1 = allRasters_1.next(); !allRasters_1_1.done; allRasters_1_1 = allRasters_1.next()) {
-                var layer = allRasters_1_1.value;
-                if (filter(layer))
-                    layers.add(layer);
-                else
-                    break;
-            }
-        }
-        catch (e_4_1) { e_4 = { error: e_4_1 }; }
-        finally {
-            try {
-                if (allRasters_1_1 && !allRasters_1_1.done && (_a = allRasters_1.return)) _a.call(allRasters_1);
-            }
-            finally { if (e_4) throw e_4.error; }
+    return (filter) => {
+        let layers = new Set();
+        for (const layer of allRasters) {
+            if (filter(layer))
+                layers.add(layer);
+            else
+                break;
         }
-        replacements.forEach(function (_a) {
-            var _b = __read(_a, 2), key = _b[0], ruleMap = _b[1];
+        replacements.forEach(([key, ruleMap]) => {
             if (layers.has(key)) {
-                layers = new Set(__spreadArray([], __read(layers), false).flatMap(function (l) { var _a; return (_a = ruleMap.get(l)) !== null && _a !== void 0 ? _a : l; }));
+                layers = new Set([...layers].flatMap((l) => { var _a; return (_a = ruleMap.get(l)) !== null && _a !== void 0 ? _a : l; }));
             }
         });
-        return __spreadArray([], __read(layers), false).reverse();
+        return [...layers].reverse();
     };
 };
 exports.continuousTimeRasters = continuousTimeRasters;