From d843eb209d17c72c42261d64d702e52b463b3473 Mon Sep 17 00:00:00 2001 From: Jean-Marie Favreau Date: Sun, 23 Feb 2025 01:20:41 +0100 Subject: [PATCH] Ajout d'une page de statistiques Fix #322 --- .../static/cal-heatmap/README.md | 1 + .../static/cal-heatmap/cal-heatmap.css | 1 + .../static/cal-heatmap/cal-heatmap.esm.js | 13211 +++++++++++++++ .../static/cal-heatmap/cal-heatmap.js | 13214 ++++++++++++++++ .../static/cal-heatmap/cal-heatmap.min.esm.js | 1 + .../cal-heatmap/cal-heatmap.min.esm.js.map | 1 + .../static/cal-heatmap/cal-heatmap.min.js | 1 + .../static/cal-heatmap/cal-heatmap.min.js.map | 1 + .../cal-heatmap/plugins/CalendarLabel.esm.js | 3793 +++++ .../cal-heatmap/plugins/CalendarLabel.js | 3801 +++++ .../plugins/CalendarLabel.min.esm.js | 1 + .../plugins/CalendarLabel.min.esm.js.map | 1 + .../cal-heatmap/plugins/CalendarLabel.min.js | 1 + .../plugins/CalendarLabel.min.js.map | 1 + .../static/cal-heatmap/plugins/Legend.esm.js | 4521 ++++++ .../static/cal-heatmap/plugins/Legend.js | 4526 ++++++ .../cal-heatmap/plugins/Legend.min.esm.js | 1 + .../cal-heatmap/plugins/Legend.min.esm.js.map | 1 + .../static/cal-heatmap/plugins/Legend.min.js | 1 + .../cal-heatmap/plugins/Legend.min.js.map | 1 + .../cal-heatmap/plugins/LegendLite.esm.js | 6128 +++++++ .../static/cal-heatmap/plugins/LegendLite.js | 6133 +++++++ .../cal-heatmap/plugins/LegendLite.min.esm.js | 1 + .../plugins/LegendLite.min.esm.js.map | 1 + .../cal-heatmap/plugins/LegendLite.min.js | 1 + .../cal-heatmap/plugins/LegendLite.min.js.map | 1 + .../static/cal-heatmap/plugins/Tooltip.esm.js | 3768 +++++ .../static/cal-heatmap/plugins/Tooltip.js | 3774 +++++ .../cal-heatmap/plugins/Tooltip.min.esm.js | 1 + .../plugins/Tooltip.min.esm.js.map | 1 + .../static/cal-heatmap/plugins/Tooltip.min.js | 1 + .../cal-heatmap/plugins/Tooltip.min.js.map | 1 + .../cal-heatmap/plugins/cal-heatmap.css | 1 + src/agenda_culturel/static/js/d3.v7.min.js | 2 + src/agenda_culturel/static/js/popper.min.js | 6 + src/agenda_culturel/static/style.scss | 4 + .../templates/agenda_culturel/page.html | 24 +- .../templates/agenda_culturel/statistics.html | 127 + src/agenda_culturel/urls.py | 1 + src/agenda_culturel/views.py | 43 +- 40 files changed, 63081 insertions(+), 18 deletions(-) create mode 100644 src/agenda_culturel/static/cal-heatmap/README.md create mode 100644 src/agenda_culturel/static/cal-heatmap/cal-heatmap.css create mode 100644 src/agenda_culturel/static/cal-heatmap/cal-heatmap.esm.js create mode 100644 src/agenda_culturel/static/cal-heatmap/cal-heatmap.js create mode 100644 src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.esm.js create mode 100644 src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.esm.js.map create mode 100644 src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.js create mode 100644 src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.js.map create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.esm.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.esm.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.esm.js.map create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.js.map create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Legend.esm.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Legend.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.esm.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.esm.js.map create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.js.map create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.esm.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.esm.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.esm.js.map create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.js.map create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.esm.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.esm.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.esm.js.map create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.js create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.js.map create mode 100644 src/agenda_culturel/static/cal-heatmap/plugins/cal-heatmap.css create mode 100644 src/agenda_culturel/static/js/d3.v7.min.js create mode 100644 src/agenda_culturel/static/js/popper.min.js create mode 100644 src/agenda_culturel/templates/agenda_culturel/statistics.html diff --git a/src/agenda_culturel/static/cal-heatmap/README.md b/src/agenda_culturel/static/cal-heatmap/README.md new file mode 100644 index 0000000..bec4603 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/README.md @@ -0,0 +1 @@ +next_month \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/cal-heatmap.css b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.css new file mode 100644 index 0000000..9bafe15 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.css @@ -0,0 +1 @@ +.ch-container{display:block}.ch-container,.ch-domain,.ch-domain-container,.ch-domain-container-animation-wrapper{overflow:visible}.ch-domain-container.in-transition .ch-domain-container-animation-wrapper{overflow:hidden}.ch-domain-bg{fill:transparent}.ch-domain-text{fill:currentColor;font-size:10px}.ch-subdomain{overflow:visible}.ch-subdomain-bg{fill:#ededed}.ch-subdomain-bg.highlight{stroke:#444;stroke-width:1px}.ch-subdomain-bg:hover{stroke:#000;stroke-width:1px}.ch-subdomain-text{font-size:8px;pointer-events:none}[data-theme=dark] .ch-subdomain-bg{fill:#2d333b}[data-theme=dark] .ch-subdomain-bg.highlight{stroke:#768390}[data-theme=dark] .ch-subdomain-bg:hover{stroke:#636e7b}#ch-plugin-legend>svg{background:transparent;color:currentColor}#ch-tooltip{background:#222;border-radius:2px;box-shadow:2px 2px 2px rgba(0,0,0,.2);box-sizing:border-box;color:#bbb;display:none;font-size:12px;line-height:1.4;padding:5px 10px;text-align:center}#ch-tooltip[data-show]{display:block}#ch-tooltip-arrow,#ch-tooltip-arrow:before{background:inherit;height:8px;position:absolute;width:8px}#ch-tooltip-arrow{visibility:hidden}#ch-tooltip-arrow:before{content:"";transform:rotate(45deg);visibility:visible}#ch-tooltip[data-popper-placement^=top]>#ch-tooltip-arrow{bottom:-4px;margin-left:-4px}#ch-tooltip[data-popper-placement^=bottom]>#ch-tooltip-arrow{margin-left:-4px;top:-4px}#ch-tooltip[data-popper-placement^=left]>#ch-tooltip-arrow{right:-4px}#ch-tooltip[data-popper-placement^=right]>#ch-tooltip-arrow{left:-4px}#ch-tooltip[data-theme=dark]{background:#636e7b;color:#cdd9e5} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/cal-heatmap.esm.js b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.esm.js new file mode 100644 index 0000000..0d34885 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.esm.js @@ -0,0 +1,13211 @@ +import { select } from 'd3-selection'; +import { hcl } from 'd3-color'; +import { ascending, timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear, timeMonday, timeTuesday, timeWednesday, timeThursday, timeFriday, timeSaturday, timeSunday, utcSecond, utcMinute, utcHour, utcDay, utcWeek, utcMonth, utcYear, utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSunday, descending, range, symbolAsterisk, symbolCircle, symbolCross, symbolDiamond, symbolDiamond2, symbolPlus, symbolSquare, symbolSquare2, symbolStar, symbolTimes, symbolTriangle, symbolTriangle2, symbolWye, schemeAccent, schemeCategory10, schemeDark2, schemePaired, schemePastel1, schemePastel2, schemeSet1, schemeSet2, schemeSet3, schemeTableau10, quantize, interpolateBrBG, interpolatePRGn, interpolatePiYG, interpolatePuOr, interpolateRdBu, interpolateRdGy, interpolateRdYlBu, interpolateRdYlGn, interpolateSpectral, interpolateBlues, interpolateGreens, interpolateGreys, interpolatePurples, interpolateReds, interpolateOranges, interpolateTurbo, interpolateViridis, interpolateMagma, interpolateInferno, interpolatePlasma, interpolateCividis, interpolateCubehelixDefault, interpolateWarm, interpolateCool, interpolateBuGn, interpolateBuPu, interpolateGnBu, interpolateOrRd, interpolatePuBuGn, interpolatePuBu, interpolatePuRd, interpolateRdPu, interpolateYlGnBu, interpolateYlGn, interpolateYlOrBr, interpolateYlOrRd, interpolateRainbow, interpolateSinebow, schemeBrBG, schemePRGn, schemePiYG, schemePuOr, schemeRdBu, schemeRdGy, schemeRdYlBu, schemeRdYlGn, schemeSpectral, schemeBlues, schemeGreens, schemeGreys, schemeOranges, schemePurples, schemeReds, schemeBuGn, schemeBuPu, schemeGnBu, schemeOrRd, schemePuBu, schemePuBuGn, schemePuRd, schemeRdPu, schemeYlGn, schemeYlGnBu, schemeYlOrBr, schemeYlOrRd, scaleLinear, scalePow, scaleLog, scaleSymlog, scaleQuantile, extent, ticks, interpolateNumber, reverse, scaleThreshold, scaleIdentity, max as max$4, interpolateRgb, interpolateRound, min as min$4, quantile, median, interpolateHsl, interpolateHcl, interpolateLab, scaleDiverging, scaleDivergingPow, scaleDivergingLog, scaleDivergingSymlog, piecewise, scaleTime, scaleUtc, scaleImplicit, scaleOrdinal, scalePoint, scaleBand, InternSet, sort, symbolsStroke, symbolsFill } from 'd3'; +import { text, dsv, csv, json } from 'd3-fetch'; + +function _iterableToArrayLimit(arr, i) { + var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; + if (null != _i) { + var _s, + _e, + _x, + _r, + _arr = [], + _n = !0, + _d = !1; + try { + if (_x = (_i = _i.call(arr)).next, 0 === i) { + if (Object(_i) !== _i) return; + _n = !1; + } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); + } catch (err) { + _d = !0, _e = err; + } finally { + try { + if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; + } finally { + if (_d) throw _e; + } + } + return _arr; + } +} +function _regeneratorRuntime() { + _regeneratorRuntime = function () { + return exports; + }; + var exports = {}, + Op = Object.prototype, + hasOwn = Op.hasOwnProperty, + defineProperty = Object.defineProperty || function (obj, key, desc) { + obj[key] = desc.value; + }, + $Symbol = "function" == typeof Symbol ? Symbol : {}, + iteratorSymbol = $Symbol.iterator || "@@iterator", + asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", + toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; + function define(obj, key, value) { + return Object.defineProperty(obj, key, { + value: value, + enumerable: !0, + configurable: !0, + writable: !0 + }), obj[key]; + } + try { + define({}, ""); + } catch (err) { + define = function (obj, key, value) { + return obj[key] = value; + }; + } + function wrap(innerFn, outerFn, self, tryLocsList) { + var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, + generator = Object.create(protoGenerator.prototype), + context = new Context(tryLocsList || []); + return defineProperty(generator, "_invoke", { + value: makeInvokeMethod(innerFn, self, context) + }), generator; + } + function tryCatch(fn, obj, arg) { + try { + return { + type: "normal", + arg: fn.call(obj, arg) + }; + } catch (err) { + return { + type: "throw", + arg: err + }; + } + } + exports.wrap = wrap; + var ContinueSentinel = {}; + function Generator() {} + function GeneratorFunction() {} + function GeneratorFunctionPrototype() {} + var IteratorPrototype = {}; + define(IteratorPrototype, iteratorSymbol, function () { + return this; + }); + var getProto = Object.getPrototypeOf, + NativeIteratorPrototype = getProto && getProto(getProto(values([]))); + NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); + var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); + function defineIteratorMethods(prototype) { + ["next", "throw", "return"].forEach(function (method) { + define(prototype, method, function (arg) { + return this._invoke(method, arg); + }); + }); + } + function AsyncIterator(generator, PromiseImpl) { + function invoke(method, arg, resolve, reject) { + var record = tryCatch(generator[method], generator, arg); + if ("throw" !== record.type) { + var result = record.arg, + value = result.value; + return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { + invoke("next", value, resolve, reject); + }, function (err) { + invoke("throw", err, resolve, reject); + }) : PromiseImpl.resolve(value).then(function (unwrapped) { + result.value = unwrapped, resolve(result); + }, function (error) { + return invoke("throw", error, resolve, reject); + }); + } + reject(record.arg); + } + var previousPromise; + defineProperty(this, "_invoke", { + value: function (method, arg) { + function callInvokeWithMethodAndArg() { + return new PromiseImpl(function (resolve, reject) { + invoke(method, arg, resolve, reject); + }); + } + return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); + } + }); + } + function makeInvokeMethod(innerFn, self, context) { + var state = "suspendedStart"; + return function (method, arg) { + if ("executing" === state) throw new Error("Generator is already running"); + if ("completed" === state) { + if ("throw" === method) throw arg; + return doneResult(); + } + for (context.method = method, context.arg = arg;;) { + var delegate = context.delegate; + if (delegate) { + var delegateResult = maybeInvokeDelegate(delegate, context); + if (delegateResult) { + if (delegateResult === ContinueSentinel) continue; + return delegateResult; + } + } + if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { + if ("suspendedStart" === state) throw state = "completed", context.arg; + context.dispatchException(context.arg); + } else "return" === context.method && context.abrupt("return", context.arg); + state = "executing"; + var record = tryCatch(innerFn, self, context); + if ("normal" === record.type) { + if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; + return { + value: record.arg, + done: context.done + }; + } + "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); + } + }; + } + function maybeInvokeDelegate(delegate, context) { + var methodName = context.method, + method = delegate.iterator[methodName]; + if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel; + var record = tryCatch(method, delegate.iterator, context.arg); + if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; + var info = record.arg; + return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); + } + function pushTryEntry(locs) { + var entry = { + tryLoc: locs[0] + }; + 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); + } + function resetTryEntry(entry) { + var record = entry.completion || {}; + record.type = "normal", delete record.arg, entry.completion = record; + } + function Context(tryLocsList) { + this.tryEntries = [{ + tryLoc: "root" + }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); + } + function values(iterable) { + if (iterable) { + var iteratorMethod = iterable[iteratorSymbol]; + if (iteratorMethod) return iteratorMethod.call(iterable); + if ("function" == typeof iterable.next) return iterable; + if (!isNaN(iterable.length)) { + var i = -1, + next = function next() { + for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; + return next.value = undefined, next.done = !0, next; + }; + return next.next = next; + } + } + return { + next: doneResult + }; + } + function doneResult() { + return { + value: undefined, + done: !0 + }; + } + return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { + value: GeneratorFunctionPrototype, + configurable: !0 + }), defineProperty(GeneratorFunctionPrototype, "constructor", { + value: GeneratorFunction, + configurable: !0 + }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { + var ctor = "function" == typeof genFun && genFun.constructor; + return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); + }, exports.mark = function (genFun) { + return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; + }, exports.awrap = function (arg) { + return { + __await: arg + }; + }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { + return this; + }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { + void 0 === PromiseImpl && (PromiseImpl = Promise); + var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); + return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { + return result.done ? result.value : iter.next(); + }); + }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { + return this; + }), define(Gp, "toString", function () { + return "[object Generator]"; + }), exports.keys = function (val) { + var object = Object(val), + keys = []; + for (var key in object) keys.push(key); + return keys.reverse(), function next() { + for (; keys.length;) { + var key = keys.pop(); + if (key in object) return next.value = key, next.done = !1, next; + } + return next.done = !0, next; + }; + }, exports.values = values, Context.prototype = { + constructor: Context, + reset: function (skipTempReset) { + if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); + }, + stop: function () { + this.done = !0; + var rootRecord = this.tryEntries[0].completion; + if ("throw" === rootRecord.type) throw rootRecord.arg; + return this.rval; + }, + dispatchException: function (exception) { + if (this.done) throw exception; + var context = this; + function handle(loc, caught) { + return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; + } + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i], + record = entry.completion; + if ("root" === entry.tryLoc) return handle("end"); + if (entry.tryLoc <= this.prev) { + var hasCatch = hasOwn.call(entry, "catchLoc"), + hasFinally = hasOwn.call(entry, "finallyLoc"); + if (hasCatch && hasFinally) { + if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); + if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); + } else if (hasCatch) { + if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); + } else { + if (!hasFinally) throw new Error("try statement without catch or finally"); + if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); + } + } + } + }, + abrupt: function (type, arg) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { + var finallyEntry = entry; + break; + } + } + finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); + var record = finallyEntry ? finallyEntry.completion : {}; + return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); + }, + complete: function (record, afterLoc) { + if ("throw" === record.type) throw record.arg; + return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; + }, + finish: function (finallyLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; + } + }, + catch: function (tryLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.tryLoc === tryLoc) { + var record = entry.completion; + if ("throw" === record.type) { + var thrown = record.arg; + resetTryEntry(entry); + } + return thrown; + } + } + throw new Error("illegal catch attempt"); + }, + delegateYield: function (iterable, resultName, nextLoc) { + return this.delegate = { + iterator: values(iterable), + resultName: resultName, + nextLoc: nextLoc + }, "next" === this.method && (this.arg = undefined), ContinueSentinel; + } + }, exports; +} +function _typeof(obj) { + "@babel/helpers - typeof"; + + return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { + return typeof obj; + } : function (obj) { + return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }, _typeof(obj); +} +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } +} +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; +} +function _defineProperty(obj, key, value) { + key = _toPropertyKey(key); + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); +} +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + return arr2; +} +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); +} +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); +} + +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +function getDefaultExportFromCjs (x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; +} + +var check = function (it) { + return it && it.Math === Math && it; +}; + +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +var global$n = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + +var shared$4 = {exports: {}}; + +var global$m = global$n; + +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty$9 = Object.defineProperty; + +var defineGlobalProperty$3 = function (key, value) { + try { + defineProperty$9(global$m, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$m[key] = value; + } return value; +}; + +var global$l = global$n; +var defineGlobalProperty$2 = defineGlobalProperty$3; + +var SHARED = '__core-js_shared__'; +var store$3 = global$l[SHARED] || defineGlobalProperty$2(SHARED, {}); + +var sharedStore = store$3; + +var store$2 = sharedStore; + +(shared$4.exports = function (key, value) { + return store$2[key] || (store$2[key] = value !== undefined ? value : {}); +})('versions', []).push({ + version: '3.34.0', + mode: 'global', + copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE', + source: 'https://github.com/zloirock/core-js' +}); + +var sharedExports = shared$4.exports; + +var fails$u = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + +var fails$t = fails$u; + +var functionBindNative = !fails$t(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); +}); + +var NATIVE_BIND$3 = functionBindNative; + +var FunctionPrototype$3 = Function.prototype; +var call$j = FunctionPrototype$3.call; +var uncurryThisWithBind = NATIVE_BIND$3 && FunctionPrototype$3.bind.bind(call$j, call$j); + +var functionUncurryThis = NATIVE_BIND$3 ? uncurryThisWithBind : function (fn) { + return function () { + return call$j.apply(fn, arguments); + }; +}; + +// we can't use just `it == null` since of `document.all` special case +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec +var isNullOrUndefined$8 = function (it) { + return it === null || it === undefined; +}; + +var isNullOrUndefined$7 = isNullOrUndefined$8; + +var $TypeError$g = TypeError; + +// `RequireObjectCoercible` abstract operation +// https://tc39.es/ecma262/#sec-requireobjectcoercible +var requireObjectCoercible$7 = function (it) { + if (isNullOrUndefined$7(it)) throw new $TypeError$g("Can't call method on " + it); + return it; +}; + +var requireObjectCoercible$6 = requireObjectCoercible$7; + +var $Object$4 = Object; + +// `ToObject` abstract operation +// https://tc39.es/ecma262/#sec-toobject +var toObject$a = function (argument) { + return $Object$4(requireObjectCoercible$6(argument)); +}; + +var uncurryThis$u = functionUncurryThis; +var toObject$9 = toObject$a; + +var hasOwnProperty$d = uncurryThis$u({}.hasOwnProperty); + +// `HasOwnProperty` abstract operation +// https://tc39.es/ecma262/#sec-hasownproperty +// eslint-disable-next-line es/no-object-hasown -- safe +var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty$d(toObject$9(it), key); +}; + +var uncurryThis$t = functionUncurryThis; + +var id$2 = 0; +var postfix = Math.random(); +var toString$c = uncurryThis$t(1.0.toString); + +var uid$3 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$c(++id$2 + postfix, 36); +}; + +var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || ''; + +var global$k = global$n; +var userAgent$5 = engineUserAgent; + +var process$3 = global$k.process; +var Deno$1 = global$k.Deno; +var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version; +var v8 = versions && versions.v8; +var match, version; + +if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); +} + +// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` +// so check `userAgent` even if `.v8` exists, but 0 +if (!version && userAgent$5) { + match = userAgent$5.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$5.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } +} + +var engineV8Version = version; + +/* eslint-disable es/no-symbol -- required for testing */ +var V8_VERSION$3 = engineV8Version; +var fails$s = fails$u; +var global$j = global$n; + +var $String$5 = global$j.String; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing +var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$s(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String$5(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$3 && V8_VERSION$3 < 41; +}); + +/* eslint-disable es/no-symbol -- required for testing */ +var NATIVE_SYMBOL$1 = symbolConstructorDetection; + +var useSymbolAsUid = NATIVE_SYMBOL$1 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + +var global$i = global$n; +var shared$3 = sharedExports; +var hasOwn$b = hasOwnProperty_1; +var uid$2 = uid$3; +var NATIVE_SYMBOL = symbolConstructorDetection; +var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + +var Symbol$3 = global$i.Symbol; +var WellKnownSymbolsStore = shared$3('wks'); +var createWellKnownSymbol = USE_SYMBOL_AS_UID$1 ? Symbol$3['for'] || Symbol$3 : Symbol$3 && Symbol$3.withoutSetter || uid$2; + +var wellKnownSymbol$m = function (name) { + if (!hasOwn$b(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$b(Symbol$3, name) + ? Symbol$3[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; +}; + +var wellKnownSymbol$l = wellKnownSymbol$m; + +var TO_STRING_TAG$2 = wellKnownSymbol$l('toStringTag'); +var test$1 = {}; + +test$1[TO_STRING_TAG$2] = 'z'; + +var toStringTagSupport = String(test$1) === '[object z]'; + +var documentAll$2 = typeof document == 'object' && document.all; + +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot +// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing +var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined; + +var documentAll_1 = { + all: documentAll$2, + IS_HTMLDDA: IS_HTMLDDA +}; + +var $documentAll$1 = documentAll_1; + +var documentAll$1 = $documentAll$1.all; + +// `IsCallable` abstract operation +// https://tc39.es/ecma262/#sec-iscallable +var isCallable$o = $documentAll$1.IS_HTMLDDA ? function (argument) { + return typeof argument == 'function' || argument === documentAll$1; +} : function (argument) { + return typeof argument == 'function'; +}; + +var objectDefineProperty = {}; + +var fails$r = fails$u; + +// Detect IE8's incomplete defineProperty implementation +var descriptors = !fails$r(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; +}); + +var isCallable$n = isCallable$o; +var $documentAll = documentAll_1; + +var documentAll = $documentAll.all; + +var isObject$j = $documentAll.IS_HTMLDDA ? function (it) { + return typeof it == 'object' ? it !== null : isCallable$n(it) || it === documentAll; +} : function (it) { + return typeof it == 'object' ? it !== null : isCallable$n(it); +}; + +var global$h = global$n; +var isObject$i = isObject$j; + +var document$3 = global$h.document; +// typeof document.createElement is 'object' in old IE +var EXISTS$1 = isObject$i(document$3) && isObject$i(document$3.createElement); + +var documentCreateElement$2 = function (it) { + return EXISTS$1 ? document$3.createElement(it) : {}; +}; + +var DESCRIPTORS$d = descriptors; +var fails$q = fails$u; +var createElement$1 = documentCreateElement$2; + +// Thanks to IE8 for its funny defineProperty +var ie8DomDefine = !DESCRIPTORS$d && !fails$q(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { + get: function () { return 7; } + }).a !== 7; +}); + +var DESCRIPTORS$c = descriptors; +var fails$p = fails$u; + +// V8 ~ Chrome 36- +// https://bugs.chromium.org/p/v8/issues/detail?id=3334 +var v8PrototypeDefineBug = DESCRIPTORS$c && fails$p(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; +}); + +var isObject$h = isObject$j; + +var $String$4 = String; +var $TypeError$f = TypeError; + +// `Assert: Type(argument) is Object` +var anObject$f = function (argument) { + if (isObject$h(argument)) return argument; + throw new $TypeError$f($String$4(argument) + ' is not an object'); +}; + +var NATIVE_BIND$2 = functionBindNative; + +var call$i = Function.prototype.call; + +var functionCall = NATIVE_BIND$2 ? call$i.bind(call$i) : function () { + return call$i.apply(call$i, arguments); +}; + +var global$g = global$n; +var isCallable$m = isCallable$o; + +var aFunction = function (argument) { + return isCallable$m(argument) ? argument : undefined; +}; + +var getBuiltIn$7 = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$g[namespace]) : global$g[namespace] && global$g[namespace][method]; +}; + +var uncurryThis$s = functionUncurryThis; + +var objectIsPrototypeOf = uncurryThis$s({}.isPrototypeOf); + +var getBuiltIn$6 = getBuiltIn$7; +var isCallable$l = isCallable$o; +var isPrototypeOf$2 = objectIsPrototypeOf; +var USE_SYMBOL_AS_UID = useSymbolAsUid; + +var $Object$3 = Object; + +var isSymbol$3 = USE_SYMBOL_AS_UID ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + var $Symbol = getBuiltIn$6('Symbol'); + return isCallable$l($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it)); +}; + +var $String$3 = String; + +var tryToString$5 = function (argument) { + try { + return $String$3(argument); + } catch (error) { + return 'Object'; + } +}; + +var isCallable$k = isCallable$o; +var tryToString$4 = tryToString$5; + +var $TypeError$e = TypeError; + +// `Assert: IsCallable(argument) is true` +var aCallable$a = function (argument) { + if (isCallable$k(argument)) return argument; + throw new $TypeError$e(tryToString$4(argument) + ' is not a function'); +}; + +var aCallable$9 = aCallable$a; +var isNullOrUndefined$6 = isNullOrUndefined$8; + +// `GetMethod` abstract operation +// https://tc39.es/ecma262/#sec-getmethod +var getMethod$4 = function (V, P) { + var func = V[P]; + return isNullOrUndefined$6(func) ? undefined : aCallable$9(func); +}; + +var call$h = functionCall; +var isCallable$j = isCallable$o; +var isObject$g = isObject$j; + +var $TypeError$d = TypeError; + +// `OrdinaryToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-ordinarytoprimitive +var ordinaryToPrimitive$1 = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable$j(fn = input.toString) && !isObject$g(val = call$h(fn, input))) return val; + if (isCallable$j(fn = input.valueOf) && !isObject$g(val = call$h(fn, input))) return val; + if (pref !== 'string' && isCallable$j(fn = input.toString) && !isObject$g(val = call$h(fn, input))) return val; + throw new $TypeError$d("Can't convert object to primitive value"); +}; + +var call$g = functionCall; +var isObject$f = isObject$j; +var isSymbol$2 = isSymbol$3; +var getMethod$3 = getMethod$4; +var ordinaryToPrimitive = ordinaryToPrimitive$1; +var wellKnownSymbol$k = wellKnownSymbol$m; + +var $TypeError$c = TypeError; +var TO_PRIMITIVE = wellKnownSymbol$k('toPrimitive'); + +// `ToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-toprimitive +var toPrimitive$1 = function (input, pref) { + if (!isObject$f(input) || isSymbol$2(input)) return input; + var exoticToPrim = getMethod$3(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$g(exoticToPrim, input, pref); + if (!isObject$f(result) || isSymbol$2(result)) return result; + throw new $TypeError$c("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); +}; + +var toPrimitive = toPrimitive$1; +var isSymbol$1 = isSymbol$3; + +// `ToPropertyKey` abstract operation +// https://tc39.es/ecma262/#sec-topropertykey +var toPropertyKey$3 = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol$1(key) ? key : key + ''; +}; + +var DESCRIPTORS$b = descriptors; +var IE8_DOM_DEFINE$1 = ie8DomDefine; +var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug; +var anObject$e = anObject$f; +var toPropertyKey$2 = toPropertyKey$3; + +var $TypeError$b = TypeError; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var $defineProperty = Object.defineProperty; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; +var ENUMERABLE = 'enumerable'; +var CONFIGURABLE$1 = 'configurable'; +var WRITABLE = 'writable'; + +// `Object.defineProperty` method +// https://tc39.es/ecma262/#sec-object.defineproperty +objectDefineProperty.f = DESCRIPTORS$b ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) { + anObject$e(O); + P = toPropertyKey$2(P); + anObject$e(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor$1(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); +} : $defineProperty : function defineProperty(O, P, Attributes) { + anObject$e(O); + P = toPropertyKey$2(P); + anObject$e(Attributes); + if (IE8_DOM_DEFINE$1) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$b('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + +var makeBuiltIn$3 = {exports: {}}; + +var DESCRIPTORS$a = descriptors; +var hasOwn$a = hasOwnProperty_1; + +var FunctionPrototype$2 = Function.prototype; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getDescriptor = DESCRIPTORS$a && Object.getOwnPropertyDescriptor; + +var EXISTS = hasOwn$a(FunctionPrototype$2, 'name'); +// additional protection from minified / mangled / dropped function names +var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something'; +var CONFIGURABLE = EXISTS && (!DESCRIPTORS$a || (DESCRIPTORS$a && getDescriptor(FunctionPrototype$2, 'name').configurable)); + +var functionName = { + EXISTS: EXISTS, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE +}; + +var uncurryThis$r = functionUncurryThis; +var isCallable$i = isCallable$o; +var store$1 = sharedStore; + +var functionToString$1 = uncurryThis$r(Function.toString); + +// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper +if (!isCallable$i(store$1.inspectSource)) { + store$1.inspectSource = function (it) { + return functionToString$1(it); + }; +} + +var inspectSource$3 = store$1.inspectSource; + +var global$f = global$n; +var isCallable$h = isCallable$o; + +var WeakMap$3 = global$f.WeakMap; + +var weakMapBasicDetection = isCallable$h(WeakMap$3) && /native code/.test(String(WeakMap$3)); + +var createPropertyDescriptor$4 = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + +var DESCRIPTORS$9 = descriptors; +var definePropertyModule$4 = objectDefineProperty; +var createPropertyDescriptor$3 = createPropertyDescriptor$4; + +var createNonEnumerableProperty$6 = DESCRIPTORS$9 ? function (object, key, value) { + return definePropertyModule$4.f(object, key, createPropertyDescriptor$3(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + +var shared$2 = sharedExports; +var uid$1 = uid$3; + +var keys$1 = shared$2('keys'); + +var sharedKey$3 = function (key) { + return keys$1[key] || (keys$1[key] = uid$1(key)); +}; + +var hiddenKeys$5 = {}; + +var NATIVE_WEAK_MAP = weakMapBasicDetection; +var global$e = global$n; +var isObject$e = isObject$j; +var createNonEnumerableProperty$5 = createNonEnumerableProperty$6; +var hasOwn$9 = hasOwnProperty_1; +var shared$1 = sharedStore; +var sharedKey$2 = sharedKey$3; +var hiddenKeys$4 = hiddenKeys$5; + +var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; +var TypeError$2 = global$e.TypeError; +var WeakMap$2 = global$e.WeakMap; +var set$2, get$1, has$1; + +var enforce = function (it) { + return has$1(it) ? get$1(it) : set$2(it, {}); +}; + +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject$e(it) || (state = get$1(it)).type !== TYPE) { + throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; +}; + +if (NATIVE_WEAK_MAP || shared$1.state) { + var store = shared$1.state || (shared$1.state = new WeakMap$2()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set$2 = function (it, metadata) { + if (store.has(it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get$1 = function (it) { + return store.get(it) || {}; + }; + has$1 = function (it) { + return store.has(it); + }; +} else { + var STATE = sharedKey$2('state'); + hiddenKeys$4[STATE] = true; + set$2 = function (it, metadata) { + if (hasOwn$9(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty$5(it, STATE, metadata); + return metadata; + }; + get$1 = function (it) { + return hasOwn$9(it, STATE) ? it[STATE] : {}; + }; + has$1 = function (it) { + return hasOwn$9(it, STATE); + }; +} + +var internalState = { + set: set$2, + get: get$1, + has: has$1, + enforce: enforce, + getterFor: getterFor +}; + +var uncurryThis$q = functionUncurryThis; +var fails$o = fails$u; +var isCallable$g = isCallable$o; +var hasOwn$8 = hasOwnProperty_1; +var DESCRIPTORS$8 = descriptors; +var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE; +var inspectSource$2 = inspectSource$3; +var InternalStateModule$5 = internalState; + +var enforceInternalState = InternalStateModule$5.enforce; +var getInternalState$3 = InternalStateModule$5.get; +var $String$2 = String; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty$8 = Object.defineProperty; +var stringSlice$6 = uncurryThis$q(''.slice); +var replace$3 = uncurryThis$q(''.replace); +var join = uncurryThis$q([].join); + +var CONFIGURABLE_LENGTH = DESCRIPTORS$8 && !fails$o(function () { + return defineProperty$8(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; +}); + +var TEMPLATE = String(String).split('String'); + +var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) { + if (stringSlice$6($String$2(name), 0, 7) === 'Symbol(') { + name = '[' + replace$3($String$2(name), /^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn$8(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) { + if (DESCRIPTORS$8) defineProperty$8(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn$8(options, 'arity') && value.length !== options.arity) { + defineProperty$8(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn$8(options, 'constructor') && options.constructor) { + if (DESCRIPTORS$8) defineProperty$8(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn$8(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; +}; + +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +// eslint-disable-next-line no-extend-native -- required +Function.prototype.toString = makeBuiltIn$2(function toString() { + return isCallable$g(this) && getInternalState$3(this).source || inspectSource$2(this); +}, 'toString'); + +var makeBuiltInExports = makeBuiltIn$3.exports; + +var isCallable$f = isCallable$o; +var definePropertyModule$3 = objectDefineProperty; +var makeBuiltIn$1 = makeBuiltInExports; +var defineGlobalProperty$1 = defineGlobalProperty$3; + +var defineBuiltIn$9 = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable$f(value)) makeBuiltIn$1(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty$1(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule$3.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; +}; + +var uncurryThis$p = functionUncurryThis; + +var toString$b = uncurryThis$p({}.toString); +var stringSlice$5 = uncurryThis$p(''.slice); + +var classofRaw$2 = function (it) { + return stringSlice$5(toString$b(it), 8, -1); +}; + +var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; +var isCallable$e = isCallable$o; +var classofRaw$1 = classofRaw$2; +var wellKnownSymbol$j = wellKnownSymbol$m; + +var TO_STRING_TAG$1 = wellKnownSymbol$j('toStringTag'); +var $Object$2 = Object; + +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +var classof$b = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object$2(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw$1(O) + // ES3 arguments fallback + : (result = classofRaw$1(O)) === 'Object' && isCallable$e(O.callee) ? 'Arguments' : result; +}; + +var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; +var classof$a = classof$b; + +// `Object.prototype.toString` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.tostring +var objectToString$2 = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$a(this) + ']'; +}; + +var TO_STRING_TAG_SUPPORT = toStringTagSupport; +var defineBuiltIn$8 = defineBuiltIn$9; +var toString$a = objectToString$2; + +// `Object.prototype.toString` method +// https://tc39.es/ecma262/#sec-object.prototype.tostring +if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn$8(Object.prototype, 'toString', toString$a, { unsafe: true }); +} + +var objectGetOwnPropertyDescriptor = {}; + +var objectPropertyIsEnumerable = {}; + +var $propertyIsEnumerable$1 = {}.propertyIsEnumerable; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor$3 = Object.getOwnPropertyDescriptor; + +// Nashorn ~ JDK8 bug +var NASHORN_BUG = getOwnPropertyDescriptor$3 && !$propertyIsEnumerable$1.call({ 1: 2 }, 1); + +// `Object.prototype.propertyIsEnumerable` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable +objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor$3(this, V); + return !!descriptor && descriptor.enumerable; +} : $propertyIsEnumerable$1; + +var uncurryThis$o = functionUncurryThis; +var fails$n = fails$u; +var classof$9 = classofRaw$2; + +var $Object$1 = Object; +var split = uncurryThis$o(''.split); + +// fallback for non-array-like ES3 and non-enumerable old V8 strings +var indexedObject = fails$n(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object$1('z').propertyIsEnumerable(0); +}) ? function (it) { + return classof$9(it) === 'String' ? split(it, '') : $Object$1(it); +} : $Object$1; + +// toObject with fallback for non-array-like ES3 strings +var IndexedObject$3 = indexedObject; +var requireObjectCoercible$5 = requireObjectCoercible$7; + +var toIndexedObject$9 = function (it) { + return IndexedObject$3(requireObjectCoercible$5(it)); +}; + +var DESCRIPTORS$7 = descriptors; +var call$f = functionCall; +var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; +var createPropertyDescriptor$2 = createPropertyDescriptor$4; +var toIndexedObject$8 = toIndexedObject$9; +var toPropertyKey$1 = toPropertyKey$3; +var hasOwn$7 = hasOwnProperty_1; +var IE8_DOM_DEFINE = ie8DomDefine; + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor +objectGetOwnPropertyDescriptor.f = DESCRIPTORS$7 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$8(O); + P = toPropertyKey$1(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn$7(O, P)) return createPropertyDescriptor$2(!call$f(propertyIsEnumerableModule$1.f, O, P), O[P]); +}; + +var objectGetOwnPropertyNames = {}; + +var ceil = Math.ceil; +var floor$2 = Math.floor; + +// `Math.trunc` method +// https://tc39.es/ecma262/#sec-math.trunc +// eslint-disable-next-line es/no-math-trunc -- safe +var mathTrunc = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor$2 : ceil)(n); +}; + +var trunc = mathTrunc; + +// `ToIntegerOrInfinity` abstract operation +// https://tc39.es/ecma262/#sec-tointegerorinfinity +var toIntegerOrInfinity$4 = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); +}; + +var toIntegerOrInfinity$3 = toIntegerOrInfinity$4; + +var max$3 = Math.max; +var min$3 = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). +var toAbsoluteIndex$4 = function (index, length) { + var integer = toIntegerOrInfinity$3(index); + return integer < 0 ? max$3(integer + length, 0) : min$3(integer, length); +}; + +var toIntegerOrInfinity$2 = toIntegerOrInfinity$4; + +var min$2 = Math.min; + +// `ToLength` abstract operation +// https://tc39.es/ecma262/#sec-tolength +var toLength$3 = function (argument) { + return argument > 0 ? min$2(toIntegerOrInfinity$2(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + +var toLength$2 = toLength$3; + +// `LengthOfArrayLike` abstract operation +// https://tc39.es/ecma262/#sec-lengthofarraylike +var lengthOfArrayLike$9 = function (obj) { + return toLength$2(obj.length); +}; + +var toIndexedObject$7 = toIndexedObject$9; +var toAbsoluteIndex$3 = toAbsoluteIndex$4; +var lengthOfArrayLike$8 = lengthOfArrayLike$9; + +// `Array.prototype.{ indexOf, includes }` methods implementation +var createMethod$4 = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject$7($this); + var length = lengthOfArrayLike$8(O); + var index = toAbsoluteIndex$3(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod$4(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod$4(false) +}; + +var uncurryThis$n = functionUncurryThis; +var hasOwn$6 = hasOwnProperty_1; +var toIndexedObject$6 = toIndexedObject$9; +var indexOf$1 = arrayIncludes.indexOf; +var hiddenKeys$3 = hiddenKeys$5; + +var push$4 = uncurryThis$n([].push); + +var objectKeysInternal = function (object, names) { + var O = toIndexedObject$6(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn$6(hiddenKeys$3, key) && hasOwn$6(O, key) && push$4(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn$6(O, key = names[i++])) { + ~indexOf$1(result, key) || push$4(result, key); + } + return result; +}; + +// IE8- don't enum bug keys +var enumBugKeys$3 = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + +var internalObjectKeys$1 = objectKeysInternal; +var enumBugKeys$2 = enumBugKeys$3; + +var hiddenKeys$2 = enumBugKeys$2.concat('length', 'prototype'); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +// eslint-disable-next-line es/no-object-getownpropertynames -- safe +objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys$2); +}; + +var objectGetOwnPropertySymbols = {}; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe +objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; + +var getBuiltIn$5 = getBuiltIn$7; +var uncurryThis$m = functionUncurryThis; +var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames; +var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; +var anObject$d = anObject$f; + +var concat$2 = uncurryThis$m([].concat); + +// all object keys, includes non-enumerable and symbols +var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule$1.f(anObject$d(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f; + return getOwnPropertySymbols ? concat$2(keys, getOwnPropertySymbols(it)) : keys; +}; + +var hasOwn$5 = hasOwnProperty_1; +var ownKeys = ownKeys$1; +var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; +var definePropertyModule$2 = objectDefineProperty; + +var copyConstructorProperties$1 = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule$2.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn$5(target, key) && !(exceptions && hasOwn$5(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } +}; + +var fails$m = fails$u; +var isCallable$d = isCallable$o; + +var replacement = /#|\.prototype\./; + +var isForced$3 = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable$d(detection) ? fails$m(detection) + : !!detection; +}; + +var normalize = isForced$3.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced$3.data = {}; +var NATIVE = isForced$3.NATIVE = 'N'; +var POLYFILL = isForced$3.POLYFILL = 'P'; + +var isForced_1 = isForced$3; + +var global$d = global$n; +var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f; +var createNonEnumerableProperty$4 = createNonEnumerableProperty$6; +var defineBuiltIn$7 = defineBuiltIn$9; +var defineGlobalProperty = defineGlobalProperty$3; +var copyConstructorProperties = copyConstructorProperties$1; +var isForced$2 = isForced_1; + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key +*/ +var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global$d; + } else if (STATIC) { + target = global$d[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = (global$d[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor$2(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced$2(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty$4(sourceProperty, 'sham', true); + } + defineBuiltIn$7(target, key, sourceProperty, options); + } +}; + +var global$c = global$n; +var classof$8 = classofRaw$2; + +var engineIsNode = classof$8(global$c.process) === 'process'; + +var uncurryThis$l = functionUncurryThis; +var aCallable$8 = aCallable$a; + +var functionUncurryThisAccessor = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis$l(aCallable$8(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } +}; + +var isCallable$c = isCallable$o; + +var $String$1 = String; +var $TypeError$a = TypeError; + +var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$c(argument)) return argument; + throw new $TypeError$a("Can't set " + $String$1(argument) + ' as a prototype'); +}; + +/* eslint-disable no-proto -- safe */ +var uncurryThisAccessor = functionUncurryThisAccessor; +var anObject$c = anObject$f; +var aPossiblePrototype = aPossiblePrototype$1; + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +// Works with __proto__ only. Old v8 can't work with null proto objects. +// eslint-disable-next-line es/no-object-setprototypeof -- safe +var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject$c(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + +var defineProperty$7 = objectDefineProperty.f; +var hasOwn$4 = hasOwnProperty_1; +var wellKnownSymbol$i = wellKnownSymbol$m; + +var TO_STRING_TAG = wellKnownSymbol$i('toStringTag'); + +var setToStringTag$5 = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$4(target, TO_STRING_TAG)) { + defineProperty$7(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + +var makeBuiltIn = makeBuiltInExports; +var defineProperty$6 = objectDefineProperty; + +var defineBuiltInAccessor$3 = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true }); + return defineProperty$6.f(target, name, descriptor); +}; + +var getBuiltIn$4 = getBuiltIn$7; +var defineBuiltInAccessor$2 = defineBuiltInAccessor$3; +var wellKnownSymbol$h = wellKnownSymbol$m; +var DESCRIPTORS$6 = descriptors; + +var SPECIES$6 = wellKnownSymbol$h('species'); + +var setSpecies$2 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME); + + if (DESCRIPTORS$6 && Constructor && !Constructor[SPECIES$6]) { + defineBuiltInAccessor$2(Constructor, SPECIES$6, { + configurable: true, + get: function () { return this; } + }); + } +}; + +var isPrototypeOf$1 = objectIsPrototypeOf; + +var $TypeError$9 = TypeError; + +var anInstance$4 = function (it, Prototype) { + if (isPrototypeOf$1(Prototype, it)) return it; + throw new $TypeError$9('Incorrect invocation'); +}; + +var uncurryThis$k = functionUncurryThis; +var fails$l = fails$u; +var isCallable$b = isCallable$o; +var classof$7 = classof$b; +var getBuiltIn$3 = getBuiltIn$7; +var inspectSource$1 = inspectSource$3; + +var noop = function () { /* empty */ }; +var empty = []; +var construct = getBuiltIn$3('Reflect', 'construct'); +var constructorRegExp = /^\s*(?:class|function)\b/; +var exec$1 = uncurryThis$k(constructorRegExp.exec); +var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + +var isConstructorModern = function isConstructor(argument) { + if (!isCallable$b(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } +}; + +var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$b(argument)) return false; + switch (classof$7(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec$1(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } +}; + +isConstructorLegacy.sham = true; + +// `IsConstructor` abstract operation +// https://tc39.es/ecma262/#sec-isconstructor +var isConstructor$4 = !construct || fails$l(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; +}) ? isConstructorLegacy : isConstructorModern; + +var isConstructor$3 = isConstructor$4; +var tryToString$3 = tryToString$5; + +var $TypeError$8 = TypeError; + +// `Assert: IsConstructor(argument) is true` +var aConstructor$1 = function (argument) { + if (isConstructor$3(argument)) return argument; + throw new $TypeError$8(tryToString$3(argument) + ' is not a constructor'); +}; + +var anObject$b = anObject$f; +var aConstructor = aConstructor$1; +var isNullOrUndefined$5 = isNullOrUndefined$8; +var wellKnownSymbol$g = wellKnownSymbol$m; + +var SPECIES$5 = wellKnownSymbol$g('species'); + +// `SpeciesConstructor` abstract operation +// https://tc39.es/ecma262/#sec-speciesconstructor +var speciesConstructor$1 = function (O, defaultConstructor) { + var C = anObject$b(O).constructor; + var S; + return C === undefined || isNullOrUndefined$5(S = anObject$b(C)[SPECIES$5]) ? defaultConstructor : aConstructor(S); +}; + +var NATIVE_BIND$1 = functionBindNative; + +var FunctionPrototype$1 = Function.prototype; +var apply$3 = FunctionPrototype$1.apply; +var call$e = FunctionPrototype$1.call; + +// eslint-disable-next-line es/no-reflect -- safe +var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$e.bind(apply$3) : function () { + return call$e.apply(apply$3, arguments); +}); + +var classofRaw = classofRaw$2; +var uncurryThis$j = functionUncurryThis; + +var functionUncurryThisClause = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis$j(fn); +}; + +var uncurryThis$i = functionUncurryThisClause; +var aCallable$7 = aCallable$a; +var NATIVE_BIND = functionBindNative; + +var bind$7 = uncurryThis$i(uncurryThis$i.bind); + +// optional / simple context binding +var functionBindContext = function (fn, that) { + aCallable$7(fn); + return that === undefined ? fn : NATIVE_BIND ? bind$7(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; +}; + +var getBuiltIn$2 = getBuiltIn$7; + +var html$2 = getBuiltIn$2('document', 'documentElement'); + +var uncurryThis$h = functionUncurryThis; + +var arraySlice$3 = uncurryThis$h([].slice); + +var $TypeError$7 = TypeError; + +var validateArgumentsLength$1 = function (passed, required) { + if (passed < required) throw new $TypeError$7('Not enough arguments'); + return passed; +}; + +var userAgent$4 = engineUserAgent; + +// eslint-disable-next-line redos/no-vulnerable -- safe +var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$4); + +var global$b = global$n; +var apply$2 = functionApply; +var bind$6 = functionBindContext; +var isCallable$a = isCallable$o; +var hasOwn$3 = hasOwnProperty_1; +var fails$k = fails$u; +var html$1 = html$2; +var arraySlice$2 = arraySlice$3; +var createElement = documentCreateElement$2; +var validateArgumentsLength = validateArgumentsLength$1; +var IS_IOS$1 = engineIsIos; +var IS_NODE$3 = engineIsNode; + +var set$1 = global$b.setImmediate; +var clear = global$b.clearImmediate; +var process$2 = global$b.process; +var Dispatch = global$b.Dispatch; +var Function$1 = global$b.Function; +var MessageChannel = global$b.MessageChannel; +var String$1 = global$b.String; +var counter = 0; +var queue$2 = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var $location, defer, channel, port; + +fails$k(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = global$b.location; +}); + +var run = function (id) { + if (hasOwn$3(queue$2, id)) { + var fn = queue$2[id]; + delete queue$2[id]; + fn(); + } +}; + +var runner = function (id) { + return function () { + run(id); + }; +}; + +var eventListener = function (event) { + run(event.data); +}; + +var globalPostMessageDefer = function (id) { + // old engines have not location.origin + global$b.postMessage(String$1(id), $location.protocol + '//' + $location.host); +}; + +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!set$1 || !clear) { + set$1 = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable$a(handler) ? handler : Function$1(handler); + var args = arraySlice$2(arguments, 1); + queue$2[++counter] = function () { + apply$2(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue$2[id]; + }; + // Node.js 0.8- + if (IS_NODE$3) { + defer = function (id) { + process$2.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS$1) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind$6(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global$b.addEventListener && + isCallable$a(global$b.postMessage) && + !global$b.importScripts && + $location && $location.protocol !== 'file:' && + !fails$k(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + global$b.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html$1.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } +} + +var task$1 = { + set: set$1, + clear: clear +}; + +var Queue$2 = function () { + this.head = null; + this.tail = null; +}; + +Queue$2.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } +}; + +var queue$1 = Queue$2; + +var userAgent$3 = engineUserAgent; + +var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$3) && typeof Pebble != 'undefined'; + +var userAgent$2 = engineUserAgent; + +var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent$2); + +var global$a = global$n; +var bind$5 = functionBindContext; +var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; +var macrotask = task$1.set; +var Queue$1 = queue$1; +var IS_IOS = engineIsIos; +var IS_IOS_PEBBLE = engineIsIosPebble; +var IS_WEBOS_WEBKIT = engineIsWebosWebkit; +var IS_NODE$2 = engineIsNode; + +var MutationObserver = global$a.MutationObserver || global$a.WebKitMutationObserver; +var document$2 = global$a.document; +var process$1 = global$a.process; +var Promise$3 = global$a.Promise; +// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` +var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$a, 'queueMicrotask'); +var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; +var notify$1, toggle, node, promise, then; + +// modern engines have queueMicrotask method +if (!microtask$1) { + var queue = new Queue$1(); + + var flush = function () { + var parent, fn; + if (IS_NODE$2 && (parent = process$1.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify$1(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { + toggle = true; + node = document$2.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify$1 = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise$3 && Promise$3.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise$3.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise$3; + then = bind$5(promise.then, promise); + notify$1 = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE$2) { + notify$1 = function () { + process$1.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind$5(macrotask, global$a); + notify$1 = function () { + macrotask(flush); + }; + } + + microtask$1 = function (fn) { + if (!queue.head) notify$1(); + queue.add(fn); + }; +} + +var microtask_1 = microtask$1; + +var hostReportErrors$1 = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } +}; + +var perform$4 = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } +}; + +var global$9 = global$n; + +var promiseNativeConstructor = global$9.Promise; + +/* global Deno -- Deno case */ +var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object'; + +var IS_DENO$1 = engineIsDeno; +var IS_NODE$1 = engineIsNode; + +var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 + && typeof window == 'object' + && typeof document == 'object'; + +var global$8 = global$n; +var NativePromiseConstructor$3 = promiseNativeConstructor; +var isCallable$9 = isCallable$o; +var isForced$1 = isForced_1; +var inspectSource = inspectSource$3; +var wellKnownSymbol$f = wellKnownSymbol$m; +var IS_BROWSER = engineIsBrowser; +var IS_DENO = engineIsDeno; +var V8_VERSION$2 = engineV8Version; + +NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype; +var SPECIES$4 = wellKnownSymbol$f('species'); +var SUBCLASSING = false; +var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$9(global$8.PromiseRejectionEvent); + +var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION$2 === 66) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION$2 || V8_VERSION$2 < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES$4] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1; +}); + +var promiseConstructorDetection = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1, + SUBCLASSING: SUBCLASSING +}; + +var newPromiseCapability$2 = {}; + +var aCallable$6 = aCallable$a; + +var $TypeError$6 = TypeError; + +var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError$6('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable$6(resolve); + this.reject = aCallable$6(reject); +}; + +// `NewPromiseCapability` abstract operation +// https://tc39.es/ecma262/#sec-newpromisecapability +newPromiseCapability$2.f = function (C) { + return new PromiseCapability(C); +}; + +var $$p = _export; +var IS_NODE = engineIsNode; +var global$7 = global$n; +var call$d = functionCall; +var defineBuiltIn$6 = defineBuiltIn$9; +var setPrototypeOf$2 = objectSetPrototypeOf; +var setToStringTag$4 = setToStringTag$5; +var setSpecies$1 = setSpecies$2; +var aCallable$5 = aCallable$a; +var isCallable$8 = isCallable$o; +var isObject$d = isObject$j; +var anInstance$3 = anInstance$4; +var speciesConstructor = speciesConstructor$1; +var task = task$1.set; +var microtask = microtask_1; +var hostReportErrors = hostReportErrors$1; +var perform$3 = perform$4; +var Queue = queue$1; +var InternalStateModule$4 = internalState; +var NativePromiseConstructor$2 = promiseNativeConstructor; +var PromiseConstructorDetection = promiseConstructorDetection; +var newPromiseCapabilityModule$4 = newPromiseCapability$2; + +var PROMISE = 'Promise'; +var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR; +var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; +var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; +var getInternalPromiseState = InternalStateModule$4.getterFor(PROMISE); +var setInternalState$4 = InternalStateModule$4.set; +var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype; +var PromiseConstructor = NativePromiseConstructor$2; +var PromisePrototype = NativePromisePrototype$1; +var TypeError$1 = global$7.TypeError; +var document$1 = global$7.document; +var process = global$7.process; +var newPromiseCapability$1 = newPromiseCapabilityModule$4.f; +var newGenericPromiseCapability = newPromiseCapability$1; + +var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$7.dispatchEvent); +var UNHANDLED_REJECTION = 'unhandledrejection'; +var REJECTION_HANDLED = 'rejectionhandled'; +var PENDING = 0; +var FULFILLED = 1; +var REJECTED = 2; +var HANDLED = 1; +var UNHANDLED = 2; + +var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + +// helpers +var isThenable = function (it) { + var then; + return isObject$d(it) && isCallable$8(then = it.then) ? then : false; +}; + +var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$d(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } +}; + +var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); +}; + +var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$1.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global$7.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$7['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); +}; + +var onUnhandled = function (state) { + call$d(task, global$7, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform$3(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); +}; + +var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; +}; + +var onHandleUnhandled = function (state) { + call$d(task, global$7, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); +}; + +var bind$4 = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; +}; + +var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); +}; + +var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call$d(then, value, + bind$4(internalResolve, wrapper, state), + bind$4(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } +}; + +// constructor polyfill +if (FORCED_PROMISE_CONSTRUCTOR$4) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance$3(this, PromisePrototype); + aCallable$5(executor); + call$d(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind$4(internalResolve, state), bind$4(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState$4(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: undefined + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn$6(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable$8(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$8(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind$4(internalResolve, state); + this.reject = bind$4(internalReject, state); + }; + + newPromiseCapabilityModule$4.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (isCallable$8(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) { + nativeThen = NativePromisePrototype$1.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn$6(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call$d(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype$1.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf$2) { + setPrototypeOf$2(NativePromisePrototype$1, PromisePrototype); + } + } +} + +$$p({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, { + Promise: PromiseConstructor +}); + +setToStringTag$4(PromiseConstructor, PROMISE, false); +setSpecies$1(PROMISE); + +var iterators = {}; + +var wellKnownSymbol$e = wellKnownSymbol$m; +var Iterators$4 = iterators; + +var ITERATOR$5 = wellKnownSymbol$e('iterator'); +var ArrayPrototype$1 = Array.prototype; + +// check on default Array iterator +var isArrayIteratorMethod$2 = function (it) { + return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$5] === it); +}; + +var classof$6 = classof$b; +var getMethod$2 = getMethod$4; +var isNullOrUndefined$4 = isNullOrUndefined$8; +var Iterators$3 = iterators; +var wellKnownSymbol$d = wellKnownSymbol$m; + +var ITERATOR$4 = wellKnownSymbol$d('iterator'); + +var getIteratorMethod$3 = function (it) { + if (!isNullOrUndefined$4(it)) return getMethod$2(it, ITERATOR$4) + || getMethod$2(it, '@@iterator') + || Iterators$3[classof$6(it)]; +}; + +var call$c = functionCall; +var aCallable$4 = aCallable$a; +var anObject$a = anObject$f; +var tryToString$2 = tryToString$5; +var getIteratorMethod$2 = getIteratorMethod$3; + +var $TypeError$5 = TypeError; + +var getIterator$2 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$2(argument) : usingIterator; + if (aCallable$4(iteratorMethod)) return anObject$a(call$c(iteratorMethod, argument)); + throw new $TypeError$5(tryToString$2(argument) + ' is not iterable'); +}; + +var call$b = functionCall; +var anObject$9 = anObject$f; +var getMethod$1 = getMethod$4; + +var iteratorClose$2 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$9(iterator); + try { + innerResult = getMethod$1(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$b(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$9(innerResult); + return value; +}; + +var bind$3 = functionBindContext; +var call$a = functionCall; +var anObject$8 = anObject$f; +var tryToString$1 = tryToString$5; +var isArrayIteratorMethod$1 = isArrayIteratorMethod$2; +var lengthOfArrayLike$7 = lengthOfArrayLike$9; +var isPrototypeOf = objectIsPrototypeOf; +var getIterator$1 = getIterator$2; +var getIteratorMethod$1 = getIteratorMethod$3; +var iteratorClose$1 = iteratorClose$2; + +var $TypeError$4 = TypeError; + +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; + +var ResultPrototype = Result.prototype; + +var iterate$6 = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind$3(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose$1(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject$8(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod$1(iterable); + if (!iterFn) throw new $TypeError$4(tryToString$1(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod$1(iterFn)) { + for (index = 0, length = lengthOfArrayLike$7(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator$1(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call$a(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose$1(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); +}; + +var wellKnownSymbol$c = wellKnownSymbol$m; + +var ITERATOR$3 = wellKnownSymbol$c('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR$3] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +var checkCorrectnessOfIteration$3 = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR$3] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + +var NativePromiseConstructor$1 = promiseNativeConstructor; +var checkCorrectnessOfIteration$2 = checkCorrectnessOfIteration$3; +var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR; + +var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration$2(function (iterable) { + NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ }); +}); + +var $$o = _export; +var call$9 = functionCall; +var aCallable$3 = aCallable$a; +var newPromiseCapabilityModule$3 = newPromiseCapability$2; +var perform$2 = perform$4; +var iterate$5 = iterate$6; +var PROMISE_STATICS_INCORRECT_ITERATION$2 = promiseStaticsIncorrectIteration; + +// `Promise.all` method +// https://tc39.es/ecma262/#sec-promise.all +$$o({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$2 }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$3.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform$2(function () { + var $promiseResolve = aCallable$3(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$5(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$9($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var $$n = _export; +var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR; +var NativePromiseConstructor = promiseNativeConstructor; +var getBuiltIn$1 = getBuiltIn$7; +var isCallable$7 = isCallable$o; +var defineBuiltIn$5 = defineBuiltIn$9; + +var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + +// `Promise.prototype.catch` method +// https://tc39.es/ecma262/#sec-promise.prototype.catch +$$n({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } +}); + +// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` +if (isCallable$7(NativePromiseConstructor)) { + var method = getBuiltIn$1('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn$5(NativePromisePrototype, 'catch', method, { unsafe: true }); + } +} + +var $$m = _export; +var call$8 = functionCall; +var aCallable$2 = aCallable$a; +var newPromiseCapabilityModule$2 = newPromiseCapability$2; +var perform$1 = perform$4; +var iterate$4 = iterate$6; +var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration; + +// `Promise.race` method +// https://tc39.es/ecma262/#sec-promise.race +$$m({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$2.f(C); + var reject = capability.reject; + var result = perform$1(function () { + var $promiseResolve = aCallable$2(C.resolve); + iterate$4(iterable, function (promise) { + call$8($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var $$l = _export; +var call$7 = functionCall; +var newPromiseCapabilityModule$1 = newPromiseCapability$2; +var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR; + +// `Promise.reject` method +// https://tc39.es/ecma262/#sec-promise.reject +$$l({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule$1.f(this); + call$7(capability.reject, undefined, r); + return capability.promise; + } +}); + +var anObject$7 = anObject$f; +var isObject$c = isObject$j; +var newPromiseCapability = newPromiseCapability$2; + +var promiseResolve$1 = function (C, x) { + anObject$7(C); + if (isObject$c(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + +var $$k = _export; +var getBuiltIn = getBuiltIn$7; +var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR; +var promiseResolve = promiseResolve$1; + +getBuiltIn('Promise'); + +// `Promise.resolve` method +// https://tc39.es/ecma262/#sec-promise.resolve +$$k({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(this, x); + } +}); + +var objectDefineProperties = {}; + +var internalObjectKeys = objectKeysInternal; +var enumBugKeys$1 = enumBugKeys$3; + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +// eslint-disable-next-line es/no-object-keys -- safe +var objectKeys$3 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys$1); +}; + +var DESCRIPTORS$5 = descriptors; +var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; +var definePropertyModule$1 = objectDefineProperty; +var anObject$6 = anObject$f; +var toIndexedObject$5 = toIndexedObject$9; +var objectKeys$2 = objectKeys$3; + +// `Object.defineProperties` method +// https://tc39.es/ecma262/#sec-object.defineproperties +// eslint-disable-next-line es/no-object-defineproperties -- safe +objectDefineProperties.f = DESCRIPTORS$5 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject$6(O); + var props = toIndexedObject$5(Properties); + var keys = objectKeys$2(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]); + return O; +}; + +/* global ActiveXObject -- old IE, WSH */ +var anObject$5 = anObject$f; +var definePropertiesModule = objectDefineProperties; +var enumBugKeys = enumBugKeys$3; +var hiddenKeys$1 = hiddenKeys$5; +var html = html$2; +var documentCreateElement$1 = documentCreateElement$2; +var sharedKey$1 = sharedKey$3; + +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO$1 = sharedKey$1('IE_PROTO'); + +var EmptyConstructor = function () { /* empty */ }; + +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; + +// Create object with fake `null` prototype: use ActiveX Object with cleared prototype +var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; +}; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement$1('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; + +// Check for document.domain and active x support +// No need to use active x approach when document.domain is not set +// see https://github.com/es-shims/es5-shim/issues/150 +// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 +// avoid IE GC bug +var activeXDocument; +var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; + +hiddenKeys$1[IE_PROTO$1] = true; + +// `Object.create` method +// https://tc39.es/ecma262/#sec-object.create +// eslint-disable-next-line es/no-object-create -- safe +var objectCreate$1 = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject$5(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO$1] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : definePropertiesModule.f(result, Properties); +}; + +var wellKnownSymbol$b = wellKnownSymbol$m; +var create$3 = objectCreate$1; +var defineProperty$5 = objectDefineProperty.f; + +var UNSCOPABLES = wellKnownSymbol$b('unscopables'); +var ArrayPrototype = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype[UNSCOPABLES] === undefined) { + defineProperty$5(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create$3(null) + }); +} + +// add a key to Array.prototype[@@unscopables] +var addToUnscopables$3 = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; +}; + +var fails$j = fails$u; + +var correctPrototypeGetter = !fails$j(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + +var hasOwn$2 = hasOwnProperty_1; +var isCallable$6 = isCallable$o; +var toObject$8 = toObject$a; +var sharedKey = sharedKey$3; +var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter; + +var IE_PROTO = sharedKey('IE_PROTO'); +var $Object = Object; +var ObjectPrototype = $Object.prototype; + +// `Object.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.getprototypeof +// eslint-disable-next-line es/no-object-getprototypeof -- safe +var objectGetPrototypeOf$1 = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) { + var object = toObject$8(O); + if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable$6(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof $Object ? ObjectPrototype : null; +}; + +var fails$i = fails$u; +var isCallable$5 = isCallable$o; +var isObject$b = isObject$j; +var getPrototypeOf$1 = objectGetPrototypeOf$1; +var defineBuiltIn$4 = defineBuiltIn$9; +var wellKnownSymbol$a = wellKnownSymbol$m; + +var ITERATOR$2 = wellKnownSymbol$a('iterator'); +var BUGGY_SAFARI_ITERATORS$1 = false; + +// `%IteratorPrototype%` object +// https://tc39.es/ecma262/#sec-%iteratorprototype%-object +var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator; + +/* eslint-disable es/no-array-prototype-keys -- safe */ +if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype; + } +} + +var NEW_ITERATOR_PROTOTYPE = !isObject$b(IteratorPrototype$2) || fails$i(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype$2[ITERATOR$2].call(test) !== test; +}); + +if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {}; + +// `%IteratorPrototype%[@@iterator]()` method +// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator +if (!isCallable$5(IteratorPrototype$2[ITERATOR$2])) { + defineBuiltIn$4(IteratorPrototype$2, ITERATOR$2, function () { + return this; + }); +} + +var iteratorsCore = { + IteratorPrototype: IteratorPrototype$2, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1 +}; + +var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; +var create$2 = objectCreate$1; +var createPropertyDescriptor$1 = createPropertyDescriptor$4; +var setToStringTag$3 = setToStringTag$5; +var Iterators$2 = iterators; + +var returnThis$1 = function () { return this; }; + +var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create$2(IteratorPrototype$1, { next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next) }); + setToStringTag$3(IteratorConstructor, TO_STRING_TAG, false); + Iterators$2[TO_STRING_TAG] = returnThis$1; + return IteratorConstructor; +}; + +var $$j = _export; +var call$6 = functionCall; +var FunctionName = functionName; +var isCallable$4 = isCallable$o; +var createIteratorConstructor = iteratorCreateConstructor; +var getPrototypeOf = objectGetPrototypeOf$1; +var setPrototypeOf$1 = objectSetPrototypeOf; +var setToStringTag$2 = setToStringTag$5; +var createNonEnumerableProperty$3 = createNonEnumerableProperty$6; +var defineBuiltIn$3 = defineBuiltIn$9; +var wellKnownSymbol$9 = wellKnownSymbol$m; +var Iterators$1 = iterators; +var IteratorsCore = iteratorsCore; + +var PROPER_FUNCTION_NAME$1 = FunctionName.PROPER; +var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; +var IteratorPrototype = IteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR$1 = wellKnownSymbol$9('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; + +var returnThis = function () { return this; }; + +var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND]; + + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } + + return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR$1] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf$1) { + setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable$4(CurrentIteratorPrototype[ITERATOR$1])) { + defineBuiltIn$3(CurrentIteratorPrototype, ITERATOR$1, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag$2(CurrentIteratorPrototype, TO_STRING_TAG, true); + } + } + + // fix Array.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME$1 && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty$3(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call$6(nativeIterator, this); }; + } + } + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + defineBuiltIn$3(IterablePrototype, KEY, methods[KEY]); + } + } else $$j({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if (IterablePrototype[ITERATOR$1] !== defaultIterator) { + defineBuiltIn$3(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT }); + } + Iterators$1[NAME] = defaultIterator; + + return methods; +}; + +// `CreateIterResultObject` abstract operation +// https://tc39.es/ecma262/#sec-createiterresultobject +var createIterResultObject$3 = function (value, done) { + return { value: value, done: done }; +}; + +var toIndexedObject$4 = toIndexedObject$9; +var addToUnscopables$2 = addToUnscopables$3; +var Iterators = iterators; +var InternalStateModule$3 = internalState; +var defineProperty$4 = objectDefineProperty.f; +var defineIterator$2 = iteratorDefine; +var createIterResultObject$2 = createIterResultObject$3; +var DESCRIPTORS$4 = descriptors; + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState$3 = InternalStateModule$3.set; +var getInternalState$2 = InternalStateModule$3.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.es/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.es/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.es/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.es/ecma262/#sec-createarrayiterator +var es_array_iterator = defineIterator$2(Array, 'Array', function (iterated, kind) { + setInternalState$3(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject$4(iterated), // target + index: 0, // next index + kind: kind // kind + }); +// `%ArrayIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState$2(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return createIterResultObject$2(undefined, true); + } + switch (state.kind) { + case 'keys': return createIterResultObject$2(index, false); + case 'values': return createIterResultObject$2(target[index], false); + } return createIterResultObject$2([index, target[index]], false); +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.es/ecma262/#sec-createunmappedargumentsobject +// https://tc39.es/ecma262/#sec-createmappedargumentsobject +var values = Iterators.Arguments = Iterators.Array; + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables$2('keys'); +addToUnscopables$2('values'); +addToUnscopables$2('entries'); + +// V8 ~ Chrome 45- bug +if (DESCRIPTORS$4 && values.name !== 'values') try { + defineProperty$4(values, 'name', { value: 'values' }); +} catch (error) { /* empty */ } + +var $$i = _export; +var call$5 = functionCall; +var aCallable$1 = aCallable$a; +var newPromiseCapabilityModule = newPromiseCapability$2; +var perform = perform$4; +var iterate$3 = iterate$6; +var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration; + +// `Promise.allSettled` method +// https://tc39.es/ecma262/#sec-promise.allsettled +$$i({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + allSettled: function allSettled(iterable) { + var C = this; + var capability = newPromiseCapabilityModule.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aCallable$1(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$3(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$5(promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'fulfilled', value: value }; + --remaining || resolve(values); + }, function (error) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'rejected', reason: error }; + --remaining || resolve(values); + }); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var classof$5 = classof$b; + +var $String = String; + +var toString$9 = function (argument) { + if (classof$5(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string'); + return $String(argument); +}; + +var uncurryThis$g = functionUncurryThis; +var toIntegerOrInfinity$1 = toIntegerOrInfinity$4; +var toString$8 = toString$9; +var requireObjectCoercible$4 = requireObjectCoercible$7; + +var charAt$4 = uncurryThis$g(''.charAt); +var charCodeAt = uncurryThis$g(''.charCodeAt); +var stringSlice$4 = uncurryThis$g(''.slice); + +var createMethod$3 = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = toString$8(requireObjectCoercible$4($this)); + var position = toIntegerOrInfinity$1(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = charCodeAt(S, position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt$4(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice$4(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; +}; + +var stringMultibyte = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod$3(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod$3(true) +}; + +var charAt$3 = stringMultibyte.charAt; +var toString$7 = toString$9; +var InternalStateModule$2 = internalState; +var defineIterator$1 = iteratorDefine; +var createIterResultObject$1 = createIterResultObject$3; + +var STRING_ITERATOR = 'String Iterator'; +var setInternalState$2 = InternalStateModule$2.set; +var getInternalState$1 = InternalStateModule$2.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-string.prototype-@@iterator +defineIterator$1(String, 'String', function (iterated) { + setInternalState$2(this, { + type: STRING_ITERATOR, + string: toString$7(iterated), + index: 0 + }); +// `%StringIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next +}, function next() { + var state = getInternalState$1(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return createIterResultObject$1(undefined, true); + point = charAt$3(string, index); + state.index += point.length; + return createIterResultObject$1(point, false); +}); + +// iterable DOM collections +// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods +var domIterables = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + +// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList` +var documentCreateElement = documentCreateElement$2; + +var classList = documentCreateElement('span').classList; +var DOMTokenListPrototype$2 = classList && classList.constructor && classList.constructor.prototype; + +var domTokenListPrototype = DOMTokenListPrototype$2 === Object.prototype ? undefined : DOMTokenListPrototype$2; + +var global$6 = global$n; +var DOMIterables$1 = domIterables; +var DOMTokenListPrototype$1 = domTokenListPrototype; +var ArrayIteratorMethods = es_array_iterator; +var createNonEnumerableProperty$2 = createNonEnumerableProperty$6; +var setToStringTag$1 = setToStringTag$5; +var wellKnownSymbol$8 = wellKnownSymbol$m; + +var ITERATOR = wellKnownSymbol$8('iterator'); +var ArrayValues = ArrayIteratorMethods.values; + +var handlePrototype$1 = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty$2(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + setToStringTag$1(CollectionPrototype, COLLECTION_NAME, true); + if (DOMIterables$1[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty$2(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } +}; + +for (var COLLECTION_NAME$1 in DOMIterables$1) { + handlePrototype$1(global$6[COLLECTION_NAME$1] && global$6[COLLECTION_NAME$1].prototype, COLLECTION_NAME$1); +} + +handlePrototype$1(DOMTokenListPrototype$1, 'DOMTokenList'); + +var toObject$7 = toObject$a; +var toAbsoluteIndex$2 = toAbsoluteIndex$4; +var lengthOfArrayLike$6 = lengthOfArrayLike$9; + +// `Array.prototype.fill` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.fill +var arrayFill = function fill(value /* , start = 0, end = @length */) { + var O = toObject$7(this); + var length = lengthOfArrayLike$6(O); + var argumentsLength = arguments.length; + var index = toAbsoluteIndex$2(argumentsLength > 1 ? arguments[1] : undefined, length); + var end = argumentsLength > 2 ? arguments[2] : undefined; + var endPos = end === undefined ? length : toAbsoluteIndex$2(end, length); + while (endPos > index) O[index++] = value; + return O; +}; + +var $$h = _export; +var fill = arrayFill; +var addToUnscopables$1 = addToUnscopables$3; + +// `Array.prototype.fill` method +// https://tc39.es/ecma262/#sec-array.prototype.fill +$$h({ target: 'Array', proto: true }, { + fill: fill +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables$1('fill'); + +var classof$4 = classofRaw$2; + +// `IsArray` abstract operation +// https://tc39.es/ecma262/#sec-isarray +// eslint-disable-next-line es/no-array-isarray -- safe +var isArray$5 = Array.isArray || function isArray(argument) { + return classof$4(argument) === 'Array'; +}; + +var toPropertyKey = toPropertyKey$3; +var definePropertyModule = objectDefineProperty; +var createPropertyDescriptor = createPropertyDescriptor$4; + +var createProperty$4 = function (object, key, value) { + var propertyKey = toPropertyKey(key); + if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; +}; + +var fails$h = fails$u; +var wellKnownSymbol$7 = wellKnownSymbol$m; +var V8_VERSION$1 = engineV8Version; + +var SPECIES$3 = wellKnownSymbol$7('species'); + +var arrayMethodHasSpeciesSupport$4 = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return V8_VERSION$1 >= 51 || !fails$h(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES$3] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); +}; + +var $$g = _export; +var isArray$4 = isArray$5; +var isConstructor$2 = isConstructor$4; +var isObject$a = isObject$j; +var toAbsoluteIndex$1 = toAbsoluteIndex$4; +var lengthOfArrayLike$5 = lengthOfArrayLike$9; +var toIndexedObject$3 = toIndexedObject$9; +var createProperty$3 = createProperty$4; +var wellKnownSymbol$6 = wellKnownSymbol$m; +var arrayMethodHasSpeciesSupport$3 = arrayMethodHasSpeciesSupport$4; +var nativeSlice = arraySlice$3; + +var HAS_SPECIES_SUPPORT$2 = arrayMethodHasSpeciesSupport$3('slice'); + +var SPECIES$2 = wellKnownSymbol$6('species'); +var $Array$3 = Array; +var max$2 = Math.max; + +// `Array.prototype.slice` method +// https://tc39.es/ecma262/#sec-array.prototype.slice +// fallback for not array-like ES3 strings and DOM objects +$$g({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$2 }, { + slice: function slice(start, end) { + var O = toIndexedObject$3(this); + var length = lengthOfArrayLike$5(O); + var k = toAbsoluteIndex$1(start, length); + var fin = toAbsoluteIndex$1(end === undefined ? length : end, length); + // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible + var Constructor, result, n; + if (isArray$4(O)) { + Constructor = O.constructor; + // cross-realm fallback + if (isConstructor$2(Constructor) && (Constructor === $Array$3 || isArray$4(Constructor.prototype))) { + Constructor = undefined; + } else if (isObject$a(Constructor)) { + Constructor = Constructor[SPECIES$2]; + if (Constructor === null) Constructor = undefined; + } + if (Constructor === $Array$3 || Constructor === undefined) { + return nativeSlice(O, k, fin); + } + } + result = new (Constructor === undefined ? $Array$3 : Constructor)(max$2(fin - k, 0)); + for (n = 0; k < fin; k++, n++) if (k in O) createProperty$3(result, n, O[k]); + result.length = n; + return result; + } +}); + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise */ + + +function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +} + +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +var eventemitter3 = {exports: {}}; + +(function (module) { + + var has = Object.prototype.hasOwnProperty + , prefix = '~'; + + /** + * Constructor to create a storage for our `EE` objects. + * An `Events` instance is a plain object whose properties are event names. + * + * @constructor + * @private + */ + function Events() {} + + // + // We try to not inherit from `Object.prototype`. In some engines creating an + // instance in this way is faster than calling `Object.create(null)` directly. + // If `Object.create(null)` is not supported we prefix the event names with a + // character to make sure that the built-in object properties are not + // overridden or used as an attack vector. + // + if (Object.create) { + Events.prototype = Object.create(null); + + // + // This hack is needed because the `__proto__` property is still inherited in + // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5. + // + if (!new Events().__proto__) prefix = false; + } + + /** + * Representation of a single event listener. + * + * @param {Function} fn The listener function. + * @param {*} context The context to invoke the listener with. + * @param {Boolean} [once=false] Specify if the listener is a one-time listener. + * @constructor + * @private + */ + function EE(fn, context, once) { + this.fn = fn; + this.context = context; + this.once = once || false; + } + + /** + * Add a listener for a given event. + * + * @param {EventEmitter} emitter Reference to the `EventEmitter` instance. + * @param {(String|Symbol)} event The event name. + * @param {Function} fn The listener function. + * @param {*} context The context to invoke the listener with. + * @param {Boolean} once Specify if the listener is a one-time listener. + * @returns {EventEmitter} + * @private + */ + function addListener(emitter, event, fn, context, once) { + if (typeof fn !== 'function') { + throw new TypeError('The listener must be a function'); + } + + var listener = new EE(fn, context || emitter, once) + , evt = prefix ? prefix + event : event; + + if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++; + else if (!emitter._events[evt].fn) emitter._events[evt].push(listener); + else emitter._events[evt] = [emitter._events[evt], listener]; + + return emitter; + } + + /** + * Clear event by name. + * + * @param {EventEmitter} emitter Reference to the `EventEmitter` instance. + * @param {(String|Symbol)} evt The Event name. + * @private + */ + function clearEvent(emitter, evt) { + if (--emitter._eventsCount === 0) emitter._events = new Events(); + else delete emitter._events[evt]; + } + + /** + * Minimal `EventEmitter` interface that is molded against the Node.js + * `EventEmitter` interface. + * + * @constructor + * @public + */ + function EventEmitter() { + this._events = new Events(); + this._eventsCount = 0; + } + + /** + * Return an array listing the events for which the emitter has registered + * listeners. + * + * @returns {Array} + * @public + */ + EventEmitter.prototype.eventNames = function eventNames() { + var names = [] + , events + , name; + + if (this._eventsCount === 0) return names; + + for (name in (events = this._events)) { + if (has.call(events, name)) names.push(prefix ? name.slice(1) : name); + } + + if (Object.getOwnPropertySymbols) { + return names.concat(Object.getOwnPropertySymbols(events)); + } + + return names; + }; + + /** + * Return the listeners registered for a given event. + * + * @param {(String|Symbol)} event The event name. + * @returns {Array} The registered listeners. + * @public + */ + EventEmitter.prototype.listeners = function listeners(event) { + var evt = prefix ? prefix + event : event + , handlers = this._events[evt]; + + if (!handlers) return []; + if (handlers.fn) return [handlers.fn]; + + for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) { + ee[i] = handlers[i].fn; + } + + return ee; + }; + + /** + * Return the number of listeners listening to a given event. + * + * @param {(String|Symbol)} event The event name. + * @returns {Number} The number of listeners. + * @public + */ + EventEmitter.prototype.listenerCount = function listenerCount(event) { + var evt = prefix ? prefix + event : event + , listeners = this._events[evt]; + + if (!listeners) return 0; + if (listeners.fn) return 1; + return listeners.length; + }; + + /** + * Calls each of the listeners registered for a given event. + * + * @param {(String|Symbol)} event The event name. + * @returns {Boolean} `true` if the event had listeners, else `false`. + * @public + */ + EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) { + var evt = prefix ? prefix + event : event; + + if (!this._events[evt]) return false; + + var listeners = this._events[evt] + , len = arguments.length + , args + , i; + + if (listeners.fn) { + if (listeners.once) this.removeListener(event, listeners.fn, undefined, true); + + switch (len) { + case 1: return listeners.fn.call(listeners.context), true; + case 2: return listeners.fn.call(listeners.context, a1), true; + case 3: return listeners.fn.call(listeners.context, a1, a2), true; + case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true; + case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true; + case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true; + } + + for (i = 1, args = new Array(len -1); i < len; i++) { + args[i - 1] = arguments[i]; + } + + listeners.fn.apply(listeners.context, args); + } else { + var length = listeners.length + , j; + + for (i = 0; i < length; i++) { + if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true); + + switch (len) { + case 1: listeners[i].fn.call(listeners[i].context); break; + case 2: listeners[i].fn.call(listeners[i].context, a1); break; + case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break; + case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break; + default: + if (!args) for (j = 1, args = new Array(len -1); j < len; j++) { + args[j - 1] = arguments[j]; + } + + listeners[i].fn.apply(listeners[i].context, args); + } + } + } + + return true; + }; + + /** + * Add a listener for a given event. + * + * @param {(String|Symbol)} event The event name. + * @param {Function} fn The listener function. + * @param {*} [context=this] The context to invoke the listener with. + * @returns {EventEmitter} `this`. + * @public + */ + EventEmitter.prototype.on = function on(event, fn, context) { + return addListener(this, event, fn, context, false); + }; + + /** + * Add a one-time listener for a given event. + * + * @param {(String|Symbol)} event The event name. + * @param {Function} fn The listener function. + * @param {*} [context=this] The context to invoke the listener with. + * @returns {EventEmitter} `this`. + * @public + */ + EventEmitter.prototype.once = function once(event, fn, context) { + return addListener(this, event, fn, context, true); + }; + + /** + * Remove the listeners of a given event. + * + * @param {(String|Symbol)} event The event name. + * @param {Function} fn Only remove the listeners that match this function. + * @param {*} context Only remove the listeners that have this context. + * @param {Boolean} once Only remove one-time listeners. + * @returns {EventEmitter} `this`. + * @public + */ + EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) { + var evt = prefix ? prefix + event : event; + + if (!this._events[evt]) return this; + if (!fn) { + clearEvent(this, evt); + return this; + } + + var listeners = this._events[evt]; + + if (listeners.fn) { + if ( + listeners.fn === fn && + (!once || listeners.once) && + (!context || listeners.context === context) + ) { + clearEvent(this, evt); + } + } else { + for (var i = 0, events = [], length = listeners.length; i < length; i++) { + if ( + listeners[i].fn !== fn || + (once && !listeners[i].once) || + (context && listeners[i].context !== context) + ) { + events.push(listeners[i]); + } + } + + // + // Reset the array, or remove it completely if we have no more listeners. + // + if (events.length) this._events[evt] = events.length === 1 ? events[0] : events; + else clearEvent(this, evt); + } + + return this; + }; + + /** + * Remove all listeners, or those of the specified event. + * + * @param {(String|Symbol)} [event] The event name. + * @returns {EventEmitter} `this`. + * @public + */ + EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) { + var evt; + + if (event) { + evt = prefix ? prefix + event : event; + if (this._events[evt]) clearEvent(this, evt); + } else { + this._events = new Events(); + this._eventsCount = 0; + } + + return this; + }; + + // + // Alias methods names because people roll like that. + // + EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + EventEmitter.prototype.addListener = EventEmitter.prototype.on; + + // + // Expose the prefix. + // + EventEmitter.prefixed = prefix; + + // + // Allow `EventEmitter` to be imported as module namespace. + // + EventEmitter.EventEmitter = EventEmitter; + + // + // Expose the module. + // + { + module.exports = EventEmitter; + } +} (eventemitter3)); + +var eventemitter3Exports = eventemitter3.exports; +var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports); + +/** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ +var isArray$2 = Array.isArray; + +var isArray$3 = isArray$2; + +/** + * Casts `value` as an array if it's not one. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Lang + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast array. + * @example + * + * _.castArray(1); + * // => [1] + * + * _.castArray({ 'a': 1 }); + * // => [{ 'a': 1 }] + * + * _.castArray('abc'); + * // => ['abc'] + * + * _.castArray(null); + * // => [null] + * + * _.castArray(undefined); + * // => [undefined] + * + * _.castArray(); + * // => [] + * + * var array = [1, 2, 3]; + * console.log(_.castArray(array) === array); + * // => true + */ +function castArray() { + if (!arguments.length) { + return []; + } + var value = arguments[0]; + return isArray$3(value) ? value : [value]; +} + +var isArray$1 = isArray$5; +var isConstructor$1 = isConstructor$4; +var isObject$9 = isObject$j; +var wellKnownSymbol$5 = wellKnownSymbol$m; + +var SPECIES$1 = wellKnownSymbol$5('species'); +var $Array$2 = Array; + +// a part of `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +var arraySpeciesConstructor$1 = function (originalArray) { + var C; + if (isArray$1(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor$1(C) && (C === $Array$2 || isArray$1(C.prototype))) C = undefined; + else if (isObject$9(C)) { + C = C[SPECIES$1]; + if (C === null) C = undefined; + } + } return C === undefined ? $Array$2 : C; +}; + +var arraySpeciesConstructor = arraySpeciesConstructor$1; + +// `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +var arraySpeciesCreate$2 = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); +}; + +var bind$2 = functionBindContext; +var uncurryThis$f = functionUncurryThis; +var IndexedObject$2 = indexedObject; +var toObject$6 = toObject$a; +var lengthOfArrayLike$4 = lengthOfArrayLike$9; +var arraySpeciesCreate$1 = arraySpeciesCreate$2; + +var push$3 = uncurryThis$f([].push); + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation +var createMethod$2 = function (TYPE) { + var IS_MAP = TYPE === 1; + var IS_FILTER = TYPE === 2; + var IS_SOME = TYPE === 3; + var IS_EVERY = TYPE === 4; + var IS_FIND_INDEX = TYPE === 6; + var IS_FILTER_REJECT = TYPE === 7; + var NO_HOLES = TYPE === 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject$6($this); + var self = IndexedObject$2(O); + var length = lengthOfArrayLike$4(self); + var boundFunction = bind$2(callbackfn, that); + var index = 0; + var create = specificCreate || arraySpeciesCreate$1; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push$3(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push$3(target, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +var arrayIteration = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod$2(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod$2(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod$2(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod$2(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod$2(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod$2(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod$2(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod$2(7) +}; + +var $$f = _export; +var $map = arrayIteration.map; +var arrayMethodHasSpeciesSupport$2 = arrayMethodHasSpeciesSupport$4; + +var HAS_SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport$2('map'); + +// `Array.prototype.map` method +// https://tc39.es/ecma262/#sec-array.prototype.map +// with adding support of @@species +$$f({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$1 }, { + map: function map(callbackfn /* , thisArg */) { + return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +var DESCRIPTORS$3 = descriptors; +var uncurryThis$e = functionUncurryThis; +var call$4 = functionCall; +var fails$g = fails$u; +var objectKeys$1 = objectKeys$3; +var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; +var propertyIsEnumerableModule = objectPropertyIsEnumerable; +var toObject$5 = toObject$a; +var IndexedObject$1 = indexedObject; + +// eslint-disable-next-line es/no-object-assign -- safe +var $assign = Object.assign; +// eslint-disable-next-line es/no-object-defineproperty -- required for testing +var defineProperty$3 = Object.defineProperty; +var concat$1 = uncurryThis$e([].concat); + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +var objectAssign = !$assign || fails$g(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$3 && $assign({ b: 1 }, $assign(defineProperty$3({}, 'a', { + enumerable: true, + get: function () { + defineProperty$3(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys$1($assign({}, B)).join('') !== alphabet; +}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject$5(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject$1(arguments[index++]); + var keys = getOwnPropertySymbols ? concat$1(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$3 || call$4(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; +} : $assign; + +var $$e = _export; +var assign = objectAssign; + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +// eslint-disable-next-line es/no-object-assign -- required for testing +$$e({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign +}); + +var internalMetadata = {exports: {}}; + +var objectGetOwnPropertyNamesExternal = {}; + +var toAbsoluteIndex = toAbsoluteIndex$4; +var lengthOfArrayLike$3 = lengthOfArrayLike$9; +var createProperty$2 = createProperty$4; + +var $Array$1 = Array; +var max$1 = Math.max; + +var arraySliceSimple = function (O, start, end) { + var length = lengthOfArrayLike$3(O); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + var result = $Array$1(max$1(fin - k, 0)); + var n = 0; + for (; k < fin; k++, n++) createProperty$2(result, n, O[k]); + result.length = n; + return result; +}; + +/* eslint-disable es/no-object-getownpropertynames -- safe */ +var classof$3 = classofRaw$2; +var toIndexedObject$2 = toIndexedObject$9; +var $getOwnPropertyNames = objectGetOwnPropertyNames.f; +var arraySlice$1 = arraySliceSimple; + +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function (it) { + try { + return $getOwnPropertyNames(it); + } catch (error) { + return arraySlice$1(windowNames); + } +}; + +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames(it) { + return windowNames && classof$3(it) === 'Window' + ? getWindowNames(it) + : $getOwnPropertyNames(toIndexedObject$2(it)); +}; + +// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it +var fails$f = fails$u; + +var arrayBufferNonExtensible = fails$f(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } +}); + +var fails$e = fails$u; +var isObject$8 = isObject$j; +var classof$2 = classofRaw$2; +var ARRAY_BUFFER_NON_EXTENSIBLE = arrayBufferNonExtensible; + +// eslint-disable-next-line es/no-object-isextensible -- safe +var $isExtensible = Object.isExtensible; +var FAILS_ON_PRIMITIVES$1 = fails$e(function () { $isExtensible(1); }); + +// `Object.isExtensible` method +// https://tc39.es/ecma262/#sec-object.isextensible +var objectIsExtensible = (FAILS_ON_PRIMITIVES$1 || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) { + if (!isObject$8(it)) return false; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof$2(it) === 'ArrayBuffer') return false; + return $isExtensible ? $isExtensible(it) : true; +} : $isExtensible; + +var fails$d = fails$u; + +var freezing = !fails$d(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); +}); + +var $$d = _export; +var uncurryThis$d = functionUncurryThis; +var hiddenKeys = hiddenKeys$5; +var isObject$7 = isObject$j; +var hasOwn$1 = hasOwnProperty_1; +var defineProperty$2 = objectDefineProperty.f; +var getOwnPropertyNamesModule = objectGetOwnPropertyNames; +var getOwnPropertyNamesExternalModule = objectGetOwnPropertyNamesExternal; +var isExtensible = objectIsExtensible; +var uid = uid$3; +var FREEZING = freezing; + +var REQUIRED = false; +var METADATA = uid('meta'); +var id$1 = 0; + +var setMetadata = function (it) { + defineProperty$2(it, METADATA, { value: { + objectID: 'O' + id$1++, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey$1 = function (it, create) { + // return a primitive with prefix + if (!isObject$7(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData$1 = function (it, create) { + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn$1(it, METADATA)) setMetadata(it); + return it; +}; + +var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis$d([].splice); + var test = {}; + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $$d({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } +}; + +var meta = internalMetadata.exports = { + enable: enable, + fastKey: fastKey$1, + getWeakData: getWeakData$1, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; + +var internalMetadataExports = internalMetadata.exports; + +var isCallable$3 = isCallable$o; +var isObject$6 = isObject$j; +var setPrototypeOf = objectSetPrototypeOf; + +// makes subclassing work correct for wrapped built-ins +var inheritIfRequired$1 = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable$3(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject$6(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; +}; + +var $$c = _export; +var global$5 = global$n; +var uncurryThis$c = functionUncurryThis; +var isForced = isForced_1; +var defineBuiltIn$2 = defineBuiltIn$9; +var InternalMetadataModule = internalMetadataExports; +var iterate$2 = iterate$6; +var anInstance$2 = anInstance$4; +var isCallable$2 = isCallable$o; +var isNullOrUndefined$3 = isNullOrUndefined$8; +var isObject$5 = isObject$j; +var fails$c = fails$u; +var checkCorrectnessOfIteration$1 = checkCorrectnessOfIteration$3; +var setToStringTag = setToStringTag$5; +var inheritIfRequired = inheritIfRequired$1; + +var collection$3 = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global$5[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis$c(NativePrototype[KEY]); + defineBuiltIn$2(NativePrototype, KEY, + KEY === 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY === 'delete' ? function (key) { + return IS_WEAK && !isObject$5(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'get' ? function get(key) { + return IS_WEAK && !isObject$5(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'has' ? function has(key) { + return IS_WEAK && !isObject$5(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable$2(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails$c(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails$c(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration$1(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails$c(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance$2(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (!isNullOrUndefined$3(iterable)) iterate$2(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $$c({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported); + + setToStringTag(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + +var defineBuiltIn$1 = defineBuiltIn$9; + +var defineBuiltIns$2 = function (target, src, options) { + for (var key in src) defineBuiltIn$1(target, key, src[key], options); + return target; +}; + +var uncurryThis$b = functionUncurryThis; +var defineBuiltIns$1 = defineBuiltIns$2; +var getWeakData = internalMetadataExports.getWeakData; +var anInstance$1 = anInstance$4; +var anObject$4 = anObject$f; +var isNullOrUndefined$2 = isNullOrUndefined$8; +var isObject$4 = isObject$j; +var iterate$1 = iterate$6; +var ArrayIterationModule = arrayIteration; +var hasOwn = hasOwnProperty_1; +var InternalStateModule$1 = internalState; + +var setInternalState$1 = InternalStateModule$1.set; +var internalStateGetterFor$1 = InternalStateModule$1.getterFor; +var find = ArrayIterationModule.find; +var findIndex = ArrayIterationModule.findIndex; +var splice$1 = uncurryThis$b([].splice); +var id = 0; + +// fallback for uncaught frozen keys +var uncaughtFrozenStore = function (state) { + return state.frozen || (state.frozen = new UncaughtFrozenStore()); +}; + +var UncaughtFrozenStore = function () { + this.entries = []; +}; + +var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); +}; + +UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) splice$1(this.entries, index, 1); + return !!~index; + } +}; + +var collectionWeak$1 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance$1(that, Prototype); + setInternalState$1(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (!isNullOrUndefined$2(iterable)) iterate$1(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor$1(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject$4(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + defineBuiltIns$1(Prototype, { + // `{ WeakMap, WeakSet }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.delete + // https://tc39.es/ecma262/#sec-weakset.prototype.delete + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject$4(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && hasOwn(data, state.id) && delete data[state.id]; + }, + // `{ WeakMap, WeakSet }.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.has + // https://tc39.es/ecma262/#sec-weakset.prototype.has + has: function has(key) { + var state = getInternalState(this); + if (!isObject$4(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && hasOwn(data, state.id); + } + }); + + defineBuiltIns$1(Prototype, IS_MAP ? { + // `WeakMap.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.get + get: function get(key) { + var state = getInternalState(this); + if (isObject$4(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // `WeakMap.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.set + set: function set(key, value) { + return define(this, key, value); + } + } : { + // `WeakSet.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-weakset.prototype.add + add: function add(value) { + return define(this, value, true); + } + }); + + return Constructor; + } +}; + +var collection$2 = collection$3; +var collectionWeak = collectionWeak$1; + +// `WeakSet` constructor +// https://tc39.es/ecma262/#sec-weakset-constructor +collection$2('WeakSet', function (init) { + return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionWeak); + +var ScrollDirection; +(function (ScrollDirection) { + ScrollDirection[ScrollDirection["SCROLL_NONE"] = 0] = "SCROLL_NONE"; + ScrollDirection[ScrollDirection["SCROLL_BACKWARD"] = 1] = "SCROLL_BACKWARD"; + ScrollDirection[ScrollDirection["SCROLL_FORWARD"] = 2] = "SCROLL_FORWARD"; +})(ScrollDirection || (ScrollDirection = {})); +var Position; +(function (Position) { + Position[Position["TOP"] = 0] = "TOP"; + Position[Position["RIGHT"] = 1] = "RIGHT"; + Position[Position["BOTTOM"] = 2] = "BOTTOM"; + Position[Position["LEFT"] = 3] = "LEFT"; +})(Position || (Position = {})); +var OPTIONS_DEFAULT_DOMAIN_TYPE = 'hour'; +var OPTIONS_DEFAULT_SUBDOMAIN_TYPE = 'minute'; +var OPTIONS_DEFAULT_SUBDOMAIN_WIDTH = 10; +var OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT = 10; +var OPTIONS_DEFAULT_SUBDOMAIN_GUTTER = 2; +var OPTIONS_DEFAULT_SUBDOMAIN_RADIUS = 0; +var OPTIONS_DEFAULT_ANIMATION_DURATION = 200; +var OPTIONS_DEFAULT_RANGE = 12; +var OPTIONS_DEFAULT_ITEM_SELECTOR = '#cal-heatmap'; +var OPTIONS_DEFAULT_THEME = 'light'; +var OPTIONS_DEFAULT_LOCALE = 'en'; +var SCALE_BASE_OPACITY_COLOR = 'red'; +var SCALE_BASE_COLOR_SCHEME = 'YlOrBr'; +var SCALE_BASE_COLOR_TYPE = 'quantize'; +var SCALE_BASE_COLOR_DOMAIN = [0, 100]; + +var _Navigator_instances, _Navigator_isDomainBoundaryReached, _Navigator_setDomainsBoundaryReached; +var Navigator = /*#__PURE__*/function () { + function Navigator(calendar) { + _classCallCheck(this, Navigator); + _Navigator_instances.add(this); + this.calendar = calendar; + this.maxDomainReached = false; + this.minDomainReached = false; + } + _createClass(Navigator, [{ + key: "loadNewDomains", + value: function loadNewDomains(newDomainCollection) { + var _this = this; + var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ScrollDirection.SCROLL_NONE; + var options = this.calendar.options.options; + var templatesClt = this.calendar.templateCollection; + var minDate = options.date.min ? templatesClt.get(options.domain.type).extractUnit(+options.date.min) : undefined; + var maxDate = options.date.max ? templatesClt.get(options.domain.type).extractUnit(+options.date.max) : undefined; + var domainCollection = this.calendar.domainCollection; + if (__classPrivateFieldGet(this, _Navigator_instances, "m", _Navigator_isDomainBoundaryReached).call(this, newDomainCollection, minDate, maxDate, direction)) { + return ScrollDirection.SCROLL_NONE; + } + if (direction !== ScrollDirection.SCROLL_NONE) { + newDomainCollection.clamp(minDate, maxDate).slice(options.range, direction === ScrollDirection.SCROLL_FORWARD); + } + domainCollection.merge(newDomainCollection, options.range, function (domainKey, index) { + var subDomainEndDate = null; + if (newDomainCollection.at(index + 1)) { + subDomainEndDate = newDomainCollection.at(index + 1); + } else { + subDomainEndDate = _this.calendar.dateHelper.intervals(options.domain.type, domainKey, 2).pop(); + } + return templatesClt.get(options.subDomain.type).mapping(domainKey, subDomainEndDate).map(function (d) { + return Object.assign(Object.assign({}, d), { + v: options.data.defaultValue + }); + }); + }); + __classPrivateFieldGet(this, _Navigator_instances, "m", _Navigator_setDomainsBoundaryReached).call(this, domainCollection.min, domainCollection.max, minDate, maxDate); + if (direction === ScrollDirection.SCROLL_BACKWARD) { + this.calendar.eventEmitter.emit('domainsLoaded', [domainCollection.min]); + } else if (direction === ScrollDirection.SCROLL_FORWARD) { + this.calendar.eventEmitter.emit('domainsLoaded', [domainCollection.max]); + } + return direction; + } + }, { + key: "jumpTo", + value: function jumpTo(date, reset) { + var _this$calendar = this.calendar, + domainCollection = _this$calendar.domainCollection, + options = _this$calendar.options; + var minDate = new Date(domainCollection.min); + var maxDate = new Date(domainCollection.max); + if (date < minDate) { + return this.loadNewDomains(this.calendar.createDomainCollection(date, minDate, false), ScrollDirection.SCROLL_BACKWARD); + } + if (reset) { + return this.loadNewDomains(this.calendar.createDomainCollection(date, options.options.range), minDate < date ? ScrollDirection.SCROLL_FORWARD : ScrollDirection.SCROLL_BACKWARD); + } + if (date > maxDate) { + return this.loadNewDomains(this.calendar.createDomainCollection(maxDate, date, false), ScrollDirection.SCROLL_FORWARD); + } + return ScrollDirection.SCROLL_NONE; + } + }]); + return Navigator; +}(); +_Navigator_instances = new WeakSet(), _Navigator_isDomainBoundaryReached = function _Navigator_isDomainBoundaryReached(newDomainCollection, minDate, maxDate, direction) { + if (maxDate && newDomainCollection.max >= maxDate && this.maxDomainReached && direction === ScrollDirection.SCROLL_FORWARD) { + return true; + } + if (minDate && newDomainCollection.min <= minDate && this.minDomainReached && direction === ScrollDirection.SCROLL_BACKWARD) { + return true; + } + return false; +}, _Navigator_setDomainsBoundaryReached = function _Navigator_setDomainsBoundaryReached(lowerBound, upperBound, min, max) { + if (min) { + var reached = lowerBound <= min; + this.calendar.eventEmitter.emit(reached ? 'minDateReached' : 'minDateNotReached'); + this.minDomainReached = reached; + } + if (max) { + var _reached = upperBound >= max; + this.calendar.eventEmitter.emit(_reached ? 'maxDateReached' : 'maxDateNotReached'); + this.maxDomainReached = _reached; + } +}; + +var $TypeError$3 = TypeError; +var MAX_SAFE_INTEGER$2 = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991 + +var doesNotExceedSafeInteger$1 = function (it) { + if (it > MAX_SAFE_INTEGER$2) throw $TypeError$3('Maximum allowed index exceeded'); + return it; +}; + +var $$b = _export; +var fails$b = fails$u; +var isArray = isArray$5; +var isObject$3 = isObject$j; +var toObject$4 = toObject$a; +var lengthOfArrayLike$2 = lengthOfArrayLike$9; +var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1; +var createProperty$1 = createProperty$4; +var arraySpeciesCreate = arraySpeciesCreate$2; +var arrayMethodHasSpeciesSupport$1 = arrayMethodHasSpeciesSupport$4; +var wellKnownSymbol$4 = wellKnownSymbol$m; +var V8_VERSION = engineV8Version; + +var IS_CONCAT_SPREADABLE = wellKnownSymbol$4('isConcatSpreadable'); + +// We can't use this feature detection in V8 since it causes +// deoptimization and serious performance degradation +// https://github.com/zloirock/core-js/issues/679 +var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails$b(function () { + var array = []; + array[IS_CONCAT_SPREADABLE] = false; + return array.concat()[0] !== array; +}); + +var isConcatSpreadable = function (O) { + if (!isObject$3(O)) return false; + var spreadable = O[IS_CONCAT_SPREADABLE]; + return spreadable !== undefined ? !!spreadable : isArray(O); +}; + +var FORCED$2 = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport$1('concat'); + +// `Array.prototype.concat` method +// https://tc39.es/ecma262/#sec-array.prototype.concat +// with adding support of @@isConcatSpreadable and @@species +$$b({ target: 'Array', proto: true, arity: 1, forced: FORCED$2 }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + concat: function concat(arg) { + var O = toObject$4(this); + var A = arraySpeciesCreate(O, 0); + var n = 0; + var i, k, length, len, E; + for (i = -1, length = arguments.length; i < length; i++) { + E = i === -1 ? O : arguments[i]; + if (isConcatSpreadable(E)) { + len = lengthOfArrayLike$2(E); + doesNotExceedSafeInteger(n + len); + for (k = 0; k < len; k++, n++) if (k in E) createProperty$1(A, n, E[k]); + } else { + doesNotExceedSafeInteger(n + 1); + createProperty$1(A, n++, E); + } + } + A.length = n; + return A; + } +}); + +var fails$a = fails$u; + +var arrayMethodIsStrict$3 = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails$a(function () { + // eslint-disable-next-line no-useless-call -- required for testing + method.call(null, argument || function () { return 1; }, 1); + }); +}; + +var $$a = _export; +var uncurryThis$a = functionUncurryThis; +var IndexedObject = indexedObject; +var toIndexedObject$1 = toIndexedObject$9; +var arrayMethodIsStrict$2 = arrayMethodIsStrict$3; + +var nativeJoin = uncurryThis$a([].join); + +var ES3_STRINGS = IndexedObject !== Object; +var FORCED$1 = ES3_STRINGS || !arrayMethodIsStrict$2('join', ','); + +// `Array.prototype.join` method +// https://tc39.es/ecma262/#sec-array.prototype.join +$$a({ target: 'Array', proto: true, forced: FORCED$1 }, { + join: function join(separator) { + return nativeJoin(toIndexedObject$1(this), separator === undefined ? ',' : separator); + } +}); + +var create$1 = objectCreate$1; +var defineBuiltInAccessor$1 = defineBuiltInAccessor$3; +var defineBuiltIns = defineBuiltIns$2; +var bind$1 = functionBindContext; +var anInstance = anInstance$4; +var isNullOrUndefined$1 = isNullOrUndefined$8; +var iterate = iterate$6; +var defineIterator = iteratorDefine; +var createIterResultObject = createIterResultObject$3; +var setSpecies = setSpecies$2; +var DESCRIPTORS$2 = descriptors; +var fastKey = internalMetadataExports.fastKey; +var InternalStateModule = internalState; + +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; + +var collectionStrong$2 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + index: create$1(null), + first: undefined, + last: undefined, + size: 0 + }); + if (!DESCRIPTORS$2) that.size = 0; + if (!isNullOrUndefined$1(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + // change existing entry + if (entry) { + entry.value = value; + // create new entry + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: undefined, + removed: false + }; + if (!state.first) state.first = entry; + if (previous) previous.next = entry; + if (DESCRIPTORS$2) state.size++; + else that.size++; + // add to index + if (index !== 'F') state.index[index] = entry; + } return that; + }; + + var getEntry = function (that, key) { + var state = getInternalState(that); + // fast case + var index = fastKey(key); + var entry; + if (index !== 'F') return state.index[index]; + // frozen object case + for (entry = state.first; entry; entry = entry.next) { + if (entry.key === key) return entry; + } + }; + + defineBuiltIns(Prototype, { + // `{ Map, Set }.prototype.clear()` methods + // https://tc39.es/ecma262/#sec-map.prototype.clear + // https://tc39.es/ecma262/#sec-set.prototype.clear + clear: function clear() { + var that = this; + var state = getInternalState(that); + var data = state.index; + var entry = state.first; + while (entry) { + entry.removed = true; + if (entry.previous) entry.previous = entry.previous.next = undefined; + delete data[entry.index]; + entry = entry.next; + } + state.first = state.last = undefined; + if (DESCRIPTORS$2) state.size = 0; + else that.size = 0; + }, + // `{ Map, Set }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.delete + // https://tc39.es/ecma262/#sec-set.prototype.delete + 'delete': function (key) { + var that = this; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) prev.next = next; + if (next) next.previous = prev; + if (state.first === entry) state.first = next; + if (state.last === entry) state.last = prev; + if (DESCRIPTORS$2) state.size--; + else that.size--; + } return !!entry; + }, + // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods + // https://tc39.es/ecma262/#sec-map.prototype.foreach + // https://tc39.es/ecma262/#sec-set.prototype.foreach + forEach: function forEach(callbackfn /* , that = undefined */) { + var state = getInternalState(this); + var boundFunction = bind$1(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var entry; + while (entry = entry ? entry.next : state.first) { + boundFunction(entry.value, entry.key, this); + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + } + }, + // `{ Map, Set}.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.has + // https://tc39.es/ecma262/#sec-set.prototype.has + has: function has(key) { + return !!getEntry(this, key); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `Map.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-map.prototype.get + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + // `Map.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-map.prototype.set + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + // `Set.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-set.prototype.add + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (DESCRIPTORS$2) defineBuiltInAccessor$1(Prototype, 'size', { + configurable: true, + get: function () { + return getInternalState(this).size; + } + }); + return Constructor; + }, + setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods + // https://tc39.es/ecma262/#sec-map.prototype.entries + // https://tc39.es/ecma262/#sec-map.prototype.keys + // https://tc39.es/ecma262/#sec-map.prototype.values + // https://tc39.es/ecma262/#sec-map.prototype-@@iterator + // https://tc39.es/ecma262/#sec-set.prototype.entries + // https://tc39.es/ecma262/#sec-set.prototype.keys + // https://tc39.es/ecma262/#sec-set.prototype.values + // https://tc39.es/ecma262/#sec-set.prototype-@@iterator + defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: undefined + }); + }, function () { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + // get next entry + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + // or finish the iteration + state.target = undefined; + return createIterResultObject(undefined, true); + } + // return step by kind + if (kind === 'keys') return createIterResultObject(entry.key, false); + if (kind === 'values') return createIterResultObject(entry.value, false); + return createIterResultObject([entry.key, entry.value], false); + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + + // `{ Map, Set }.prototype[@@species]` accessors + // https://tc39.es/ecma262/#sec-get-map-@@species + // https://tc39.es/ecma262/#sec-get-set-@@species + setSpecies(CONSTRUCTOR_NAME); + } +}; + +var collection$1 = collection$3; +var collectionStrong$1 = collectionStrong$2; + +// `Map` constructor +// https://tc39.es/ecma262/#sec-map-objects +collection$1('Map', function (init) { + return function Map() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionStrong$1); + +var tryToString = tryToString$5; + +var $TypeError$2 = TypeError; + +var deletePropertyOrThrow$1 = function (O, P) { + if (!delete O[P]) throw new $TypeError$2('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O)); +}; + +var arraySlice = arraySliceSimple; + +var floor$1 = Math.floor; + +var mergeSort = function (array, comparefn) { + var length = array.length; + var middle = floor$1(length / 2); + return length < 8 ? insertionSort(array, comparefn) : merge( + array, + mergeSort(arraySlice(array, 0, middle), comparefn), + mergeSort(arraySlice(array, middle), comparefn), + comparefn + ); +}; + +var insertionSort = function (array, comparefn) { + var length = array.length; + var i = 1; + var element, j; + + while (i < length) { + j = i; + element = array[i]; + while (j && comparefn(array[j - 1], element) > 0) { + array[j] = array[--j]; + } + if (j !== i++) array[j] = element; + } return array; +}; + +var merge = function (array, left, right, comparefn) { + var llength = left.length; + var rlength = right.length; + var lindex = 0; + var rindex = 0; + + while (lindex < llength || rindex < rlength) { + array[lindex + rindex] = (lindex < llength && rindex < rlength) + ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] + : lindex < llength ? left[lindex++] : right[rindex++]; + } return array; +}; + +var arraySort = mergeSort; + +var userAgent$1 = engineUserAgent; + +var firefox = userAgent$1.match(/firefox\/(\d+)/i); + +var engineFfVersion = !!firefox && +firefox[1]; + +var UA = engineUserAgent; + +var engineIsIeOrEdge = /MSIE|Trident/.test(UA); + +var userAgent = engineUserAgent; + +var webkit = userAgent.match(/AppleWebKit\/(\d+)\./); + +var engineWebkitVersion = !!webkit && +webkit[1]; + +var $$9 = _export; +var uncurryThis$9 = functionUncurryThis; +var aCallable = aCallable$a; +var toObject$3 = toObject$a; +var lengthOfArrayLike$1 = lengthOfArrayLike$9; +var deletePropertyOrThrow = deletePropertyOrThrow$1; +var toString$6 = toString$9; +var fails$9 = fails$u; +var internalSort = arraySort; +var arrayMethodIsStrict$1 = arrayMethodIsStrict$3; +var FF = engineFfVersion; +var IE_OR_EDGE = engineIsIeOrEdge; +var V8 = engineV8Version; +var WEBKIT = engineWebkitVersion; + +var test = []; +var nativeSort = uncurryThis$9(test.sort); +var push$2 = uncurryThis$9(test.push); + +// IE8- +var FAILS_ON_UNDEFINED = fails$9(function () { + test.sort(undefined); +}); +// V8 bug +var FAILS_ON_NULL = fails$9(function () { + test.sort(null); +}); +// Old WebKit +var STRICT_METHOD$1 = arrayMethodIsStrict$1('sort'); + +var STABLE_SORT = !fails$9(function () { + // feature detection can be too slow, so check engines versions + if (V8) return V8 < 70; + if (FF && FF > 3) return; + if (IE_OR_EDGE) return true; + if (WEBKIT) return WEBKIT < 603; + + var result = ''; + var code, chr, value, index; + + // generate an array with more 512 elements (Chakra and old V8 fails only in this case) + for (code = 65; code < 76; code++) { + chr = String.fromCharCode(code); + + switch (code) { + case 66: case 69: case 70: case 72: value = 3; break; + case 68: case 71: value = 4; break; + default: value = 2; + } + + for (index = 0; index < 47; index++) { + test.push({ k: chr + index, v: value }); + } + } + + test.sort(function (a, b) { return b.v - a.v; }); + + for (index = 0; index < test.length; index++) { + chr = test[index].k.charAt(0); + if (result.charAt(result.length - 1) !== chr) result += chr; + } + + return result !== 'DGBEFHACIJK'; +}); + +var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD$1 || !STABLE_SORT; + +var getSortCompare = function (comparefn) { + return function (x, y) { + if (y === undefined) return -1; + if (x === undefined) return 1; + if (comparefn !== undefined) return +comparefn(x, y) || 0; + return toString$6(x) > toString$6(y) ? 1 : -1; + }; +}; + +// `Array.prototype.sort` method +// https://tc39.es/ecma262/#sec-array.prototype.sort +$$9({ target: 'Array', proto: true, forced: FORCED }, { + sort: function sort(comparefn) { + if (comparefn !== undefined) aCallable(comparefn); + + var array = toObject$3(this); + + if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn); + + var items = []; + var arrayLength = lengthOfArrayLike$1(array); + var itemsLength, index; + + for (index = 0; index < arrayLength; index++) { + if (index in array) push$2(items, array[index]); + } + + internalSort(items, getSortCompare(comparefn)); + + itemsLength = lengthOfArrayLike$1(items); + index = 0; + + while (index < itemsLength) array[index] = items[index++]; + while (index < arrayLength) deletePropertyOrThrow(array, index++); + + return array; + } +}); + +var $forEach = arrayIteration.forEach; +var arrayMethodIsStrict = arrayMethodIsStrict$3; + +var STRICT_METHOD = arrayMethodIsStrict('forEach'); + +// `Array.prototype.forEach` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.foreach +var arrayForEach = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); +// eslint-disable-next-line es/no-array-prototype-foreach -- safe +} : [].forEach; + +var global$4 = global$n; +var DOMIterables = domIterables; +var DOMTokenListPrototype = domTokenListPrototype; +var forEach = arrayForEach; +var createNonEnumerableProperty$1 = createNonEnumerableProperty$6; + +var handlePrototype = function (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { + createNonEnumerableProperty$1(CollectionPrototype, 'forEach', forEach); + } catch (error) { + CollectionPrototype.forEach = forEach; + } +}; + +for (var COLLECTION_NAME in DOMIterables) { + if (DOMIterables[COLLECTION_NAME]) { + handlePrototype(global$4[COLLECTION_NAME] && global$4[COLLECTION_NAME].prototype); + } +} + +handlePrototype(DOMTokenListPrototype); + +function isVertical(position) { + return position === 'top' || position === 'bottom'; +} +function horizontalPadding(padding) { + return padding[Position.LEFT] + padding[Position.RIGHT]; +} +function verticalPadding(padding) { + return padding[Position.TOP] + padding[Position.BOTTOM]; +} + +var _DomainCoordinates_instances, _DomainCoordinates_getWidth, _DomainCoordinates_getHeight; +var DomainCoordinates = /*#__PURE__*/function () { + function DomainCoordinates(calendar, domainPainter) { + _classCallCheck(this, DomainCoordinates); + _DomainCoordinates_instances.add(this); + this.calendar = calendar; + this.domainPainter = domainPainter; + this.collection = new Map(); + this.scrollDirection = ScrollDirection.SCROLL_FORWARD; + } + _createClass(DomainCoordinates, [{ + key: "get", + value: function get(domainKey) { + return this.collection.get(domainKey); + } + }, { + key: "update", + value: function update(collection, scrollDirection) { + var _this = this; + var _this$calendar$option = this.calendar.options.options, + verticalOrientation = _this$calendar$option.verticalOrientation, + domain = _this$calendar$option.domain; + this.scrollDirection = scrollDirection; + var dimensions = { + width: 0, + height: 0 + }; + var exitingTotal = 0; + var scrollFactor = scrollDirection === ScrollDirection.SCROLL_FORWARD ? -1 : 1; + var keys = collection.keys; + if (this.calendar.options.options.domain.sort === 'desc') { + keys.reverse(); + scrollFactor *= -1; + } + collection.yankedDomains.forEach(function (domainKey) { + exitingTotal += _this.collection.get(domainKey)[verticalOrientation ? 'height' : 'width']; + }); + collection.yankedDomains.forEach(function (domainKey) { + var coor = _this.collection.get(domainKey); + _this.collection.set(domainKey, Object.assign(Object.assign({}, coor), { + x: verticalOrientation ? coor.x : coor.x + exitingTotal * scrollFactor, + y: verticalOrientation ? coor.y + exitingTotal * scrollFactor : coor.y + })); + }); + keys.forEach(function (domainKey) { + var w = __classPrivateFieldGet(_this, _DomainCoordinates_instances, "m", _DomainCoordinates_getWidth).call(_this, domainKey); + var h = __classPrivateFieldGet(_this, _DomainCoordinates_instances, "m", _DomainCoordinates_getHeight).call(_this, domainKey); + if (verticalOrientation) { + dimensions.height += h; + dimensions.width = Math.max(w, dimensions.width); + } else { + dimensions.width += w; + dimensions.height = Math.max(h, dimensions.height); + } + var x = dimensions.width - w; + var y = dimensions.height - h; + _this.collection.set(domainKey, Object.assign(Object.assign({}, _this.collection.get(domainKey)), { + x: verticalOrientation ? 0 : x, + y: verticalOrientation ? y : 0, + pre_x: verticalOrientation ? x : x - exitingTotal * scrollFactor, + pre_y: verticalOrientation ? y - exitingTotal * scrollFactor : y, + width: w, + height: h, + inner_width: w - (verticalOrientation ? 0 : domain.gutter), + inner_height: h - (!verticalOrientation ? 0 : domain.gutter) + })); + }); + return dimensions; + } + }]); + return DomainCoordinates; +}(); +_DomainCoordinates_instances = new WeakSet(), _DomainCoordinates_getWidth = function _DomainCoordinates_getWidth(d) { + var _this$calendar$option2 = this.calendar.options.options, + domain = _this$calendar$option2.domain, + subDomain = _this$calendar$option2.subDomain, + x = _this$calendar$option2.x, + verticalOrientation = _this$calendar$option2.verticalOrientation; + var columnsCount = this.calendar.templateCollection.get(subDomain.type).columnsCount(d); + var subDomainWidth = (subDomain.width + subDomain.gutter) * columnsCount - subDomain.gutter; + return horizontalPadding(domain.padding) + x.domainHorizontalLabelWidth + (verticalOrientation ? 0 : domain.gutter) + subDomainWidth; +}, _DomainCoordinates_getHeight = function _DomainCoordinates_getHeight(d) { + var _this$calendar$option3 = this.calendar.options.options, + domain = _this$calendar$option3.domain, + subDomain = _this$calendar$option3.subDomain, + x = _this$calendar$option3.x, + verticalOrientation = _this$calendar$option3.verticalOrientation; + var rowsCount = this.calendar.templateCollection.get(subDomain.type).rowsCount(d); + var subDomainHeight = (subDomain.height + subDomain.gutter) * rowsCount - subDomain.gutter; + return verticalPadding(domain.padding) + subDomainHeight + (verticalOrientation ? domain.gutter : 0) + x.domainVerticalLabelHeight; +}; + +var _DomainPainter_instances, _DomainPainter_getClassName; +var DEFAULT_SELECTOR$3 = '.ch-domain'; +var DomainPainter = /*#__PURE__*/function () { + function DomainPainter(calendar) { + _classCallCheck(this, DomainPainter); + _DomainPainter_instances.add(this); + this.calendar = calendar; + this.coordinates = new DomainCoordinates(calendar, this); + this.root = null; + // Dimensions of the internal area containing all the domains + // Excluding all surrounding margins + this.dimensions = { + width: 0, + height: 0 + }; + } + _createClass(DomainPainter, [{ + key: "paint", + value: function paint(scrollDirection, rootNode) { + var _this = this; + var animationDuration = this.calendar.options.options.animationDuration; + var t = rootNode.transition().duration(animationDuration); + var coor = this.coordinates; + this.dimensions = coor.update(this.calendar.domainCollection, scrollDirection); + var promises = []; + this.root = rootNode.selectAll(DEFAULT_SELECTOR$3).data(this.calendar.domainCollection.keys, function (d) { + return d; + }).join(function (enter) { + return enter.append('svg').attr('x', function (d) { + return coor.get(d).pre_x; + }).attr('y', function (d) { + return coor.get(d).pre_y; + }).attr('width', function (d) { + return coor.get(d).inner_width; + }).attr('height', function (d) { + return coor.get(d).inner_height; + }).attr('class', function (d) { + return __classPrivateFieldGet(_this, _DomainPainter_instances, "m", _DomainPainter_getClassName).call(_this, d); + }).call(function (enterSelection) { + return enterSelection.append('rect').attr('width', function (d) { + return coor.get(d).inner_width; + }).attr('height', function (d) { + return coor.get(d).inner_height; + }).attr('class', "".concat(DEFAULT_SELECTOR$3.slice(1), "-bg")); + }).call(function (enterSelection) { + return promises.push(enterSelection.transition(t).attr('x', function (d) { + return coor.get(d).x; + }).attr('y', function (d) { + return coor.get(d).y; + }).end()); + }); + }, function (update) { + return update.call(function (updateSelection) { + return promises.push(updateSelection.transition(t).attr('x', function (d) { + return coor.get(d).x; + }).attr('y', function (d) { + return coor.get(d).y; + }).attr('width', function (d) { + return coor.get(d).inner_width; + }).attr('height', function (d) { + return coor.get(d).inner_height; + }).end()); + }).call(function (updateSelection) { + return promises.push(updateSelection.selectAll("".concat(DEFAULT_SELECTOR$3, "-bg")).transition(t).attr('width', function (d) { + return coor.get(d).inner_width; + }).attr('height', function (d) { + return coor.get(d).inner_height; + }).end()); + }); + }, function (exit) { + return exit.call(function (exitSelection) { + return promises.push(exitSelection.transition(t).attr('x', function (d) { + return coor.get(d).x; + }).attr('y', function (d) { + return coor.get(d).y; + }).remove().end()); + }); + }); + return promises; + } + }]); + return DomainPainter; +}(); +_DomainPainter_instances = new WeakSet(), _DomainPainter_getClassName = function _DomainPainter_getClassName(d) { + var classname = DEFAULT_SELECTOR$3.slice(1); + var helper = this.calendar.dateHelper.date(d); + switch (this.calendar.options.options.domain.type) { + case 'hour': + classname += " h_".concat(helper.hour()); + break; + case 'day': + classname += " d_".concat(helper.date(), " dy_").concat(helper.format('d') + 1); + break; + case 'week': + classname += " w_".concat(helper.week()); + break; + case 'month': + classname += " m_".concat(helper.month() + 1); + break; + case 'year': + classname += " y_".concat(helper.year()); + break; + } + return classname; +}; + +var $$8 = _export; +var $includes = arrayIncludes.includes; +var fails$8 = fails$u; +var addToUnscopables = addToUnscopables$3; + +// FF99+ bug +var BROKEN_ON_SPARSE = fails$8(function () { + // eslint-disable-next-line es/no-array-prototype-includes -- detection + return !Array(1).includes(); +}); + +// `Array.prototype.includes` method +// https://tc39.es/ecma262/#sec-array.prototype.includes +$$8({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, { + includes: function includes(el /* , fromIndex = 0 */) { + return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('includes'); + +var $$7 = _export; +var $filter = arrayIteration.filter; +var arrayMethodHasSpeciesSupport = arrayMethodHasSpeciesSupport$4; + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter'); + +// `Array.prototype.filter` method +// https://tc39.es/ecma262/#sec-array.prototype.filter +// with adding support of @@species +$$7({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + filter: function filter(callbackfn /* , thisArg */) { + return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +var anObject$3 = anObject$f; +var iteratorClose = iteratorClose$2; + +// call something on iterator step with safe closing on error +var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject$3(value)[0], value[1]) : fn(value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } +}; + +var bind = functionBindContext; +var call$3 = functionCall; +var toObject$2 = toObject$a; +var callWithSafeIterationClosing = callWithSafeIterationClosing$1; +var isArrayIteratorMethod = isArrayIteratorMethod$2; +var isConstructor = isConstructor$4; +var lengthOfArrayLike = lengthOfArrayLike$9; +var createProperty = createProperty$4; +var getIterator = getIterator$2; +var getIteratorMethod = getIteratorMethod$3; + +var $Array = Array; + +// `Array.from` method implementation +// https://tc39.es/ecma262/#sec-array.from +var arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { + var O = toObject$2(arrayLike); + var IS_CONSTRUCTOR = isConstructor(this); + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined); + var iteratorMethod = getIteratorMethod(O); + var index = 0; + var length, result, step, iterator, next, value; + // if the target is not iterable or it's an array with the default iterator - use a simple case + if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) { + iterator = getIterator(O, iteratorMethod); + next = iterator.next; + result = IS_CONSTRUCTOR ? new this() : []; + for (;!(step = call$3(next, iterator)).done; index++) { + value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value; + createProperty(result, index, value); + } + } else { + length = lengthOfArrayLike(O); + result = IS_CONSTRUCTOR ? new this(length) : $Array(length); + for (;length > index; index++) { + value = mapping ? mapfn(O[index], index) : O[index]; + createProperty(result, index, value); + } + } + result.length = index; + return result; +}; + +var $$6 = _export; +var from = arrayFrom; +var checkCorrectnessOfIteration = checkCorrectnessOfIteration$3; + +var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { + // eslint-disable-next-line es/no-array-from -- required for testing + Array.from(iterable); +}); + +// `Array.from` method +// https://tc39.es/ecma262/#sec-array.from +$$6({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { + from: from +}); + +var _DomainCollection_instances, _DomainCollection_setSubDomainValues, _DomainCollection_extractValues, _DomainCollection_refreshKeys; +var DOMAIN_FORMAT = { + year: 'YYYY', + month: 'MMMM', + week: 'wo [week] YYYY', + xDay: 'Do MMM', + ghDay: 'Do MMM', + day: 'Do MMM', + hour: 'HH:00', + minute: 'HH:mm' +}; +var DomainCollection = /*#__PURE__*/function () { + function DomainCollection(dateHelper, interval, start, range) { + var excludeEnd = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; + _classCallCheck(this, DomainCollection); + _DomainCollection_instances.add(this); + this.collection = new Map(); + this.dateHelper = dateHelper; + if (interval && start && range) { + var ts = this.dateHelper.intervals(interval, start, range, excludeEnd).map(function (d) { + return castArray(d); + }); + // @ts-ignore + this.collection = new Map(ts); + } + this.min = 0; + this.max = 0; + this.keys = []; + this.yankedDomains = []; + if (this.collection.size > 0) { + __classPrivateFieldGet(this, _DomainCollection_instances, "m", _DomainCollection_refreshKeys).call(this); + } + } + _createClass(DomainCollection, [{ + key: "has", + value: function has(key) { + return this.collection.has(key); + } + }, { + key: "get", + value: function get(key) { + return this.collection.get(key); + } + }, { + key: "forEach", + value: function forEach(callback) { + return this.collection.forEach(callback); + } + }, { + key: "at", + value: function at(index) { + return this.keys[index]; + } + }, { + key: "clamp", + value: function clamp(minDate, maxDate) { + var _this = this; + if (minDate && this.min < minDate) { + this.keys.filter(function (key) { + return key < minDate; + }).forEach(function (d) { + return _this.collection.delete(d); + }); + } + if (maxDate && this.max > maxDate) { + this.keys.filter(function (key) { + return key > maxDate; + }).forEach(function (d) { + return _this.collection.delete(d); + }); + } + __classPrivateFieldGet(this, _DomainCollection_instances, "m", _DomainCollection_refreshKeys).call(this); + return this; + } + }, { + key: "merge", + value: function merge(newCollection, limit, createValueCallback) { + var _this2 = this; + this.yankedDomains = []; + newCollection.keys.forEach(function (domainKey, index) { + if (_this2.has(domainKey)) { + return; + } + if (_this2.collection.size >= limit) { + var keyToRemove = _this2.max; + if (domainKey > _this2.max) { + keyToRemove = _this2.min; + } + if (keyToRemove && _this2.collection.delete(keyToRemove)) { + _this2.yankedDomains.push(keyToRemove); + } + } + _this2.collection.set(domainKey, createValueCallback(domainKey, index)); + __classPrivateFieldGet(_this2, _DomainCollection_instances, "m", _DomainCollection_refreshKeys).call(_this2); + }); + this.yankedDomains = this.yankedDomains.sort(function (a, b) { + return a - b; + }); + } + }, { + key: "slice", + value: function slice() { + var _this3 = this; + var limit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; + var fromBeginning = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + if (this.keys.length > limit) { + var keysToDelete = fromBeginning ? this.keys.slice(0, -limit) : this.keys.slice(limit); + keysToDelete.forEach(function (key) { + _this3.collection.delete(key); + }); + __classPrivateFieldGet(this, _DomainCollection_instances, "m", _DomainCollection_refreshKeys).call(this); + } + return this; + } + }, { + key: "fill", + value: function fill(data, _ref, subDomainKeyExtractor) { + var _this4 = this; + var x = _ref.x, + y = _ref.y, + groupY = _ref.groupY, + defaultValue = _ref.defaultValue; + var groupedRecords = this.groupRecords(data, x, subDomainKeyExtractor); + this.keys.forEach(function (domainKey) { + var records = groupedRecords.get(domainKey) || {}; + __classPrivateFieldGet(_this4, _DomainCollection_instances, "m", _DomainCollection_setSubDomainValues).call(_this4, domainKey, records, y, groupY, defaultValue); + }); + } + }, { + key: "groupRecords", + value: function groupRecords(data, x, subDomainKeyExtractor) { + var _this5 = this; + var results = new Map(); + var validSubDomainTimestamp = new Map(); + this.keys.forEach(function (domainKey) { + _this5.get(domainKey).forEach(function (subDomain) { + validSubDomainTimestamp.set(subDomain.t, domainKey); + }); + }); + data.forEach(function (d) { + var timestamp = _this5.extractTimestamp(d, x, subDomainKeyExtractor); + if (validSubDomainTimestamp.has(timestamp)) { + var domainKey = validSubDomainTimestamp.get(timestamp); + var records = results.get(domainKey) || {}; + records[timestamp] || (records[timestamp] = []); + records[timestamp].push(d); + results.set(domainKey, records); + } + }); + return results; + } + // eslint-disable-next-line class-methods-use-this + }, { + key: "groupValues", + value: function groupValues(values, groupFn) { + var cleanedValues = values.filter(function (n) { + return n !== null; + }); + if (typeof groupFn === 'string') { + if (cleanedValues.every(function (n) { + return typeof n === 'number'; + })) { + switch (groupFn) { + case 'sum': + return cleanedValues.reduce(function (a, b) { + return a + b; + }, 0); + case 'count': + return cleanedValues.length; + case 'min': + return Math.min.apply(Math, _toConsumableArray(cleanedValues)) || null; + case 'max': + return Math.max.apply(Math, _toConsumableArray(cleanedValues)) || null; + case 'average': + return cleanedValues.length > 0 ? cleanedValues.reduce(function (a, b) { + return a + b; + }, 0) / cleanedValues.length : null; + default: + return null; + } + } + switch (groupFn) { + case 'count': + return cleanedValues.length; + default: + return null; + } + } else if (typeof groupFn === 'function') { + return groupFn(cleanedValues); + } + return null; + } + // eslint-disable-next-line class-methods-use-this + }, { + key: "extractTimestamp", + value: function extractTimestamp(datum, x, extractorFn) { + var timestamp = typeof x === 'function' ? x(datum) : datum[x]; + if (typeof timestamp === 'string') { + timestamp = +new Date(timestamp); + } + return extractorFn(timestamp); + } + }]); + return DomainCollection; +}(); +_DomainCollection_instances = new WeakSet(), _DomainCollection_setSubDomainValues = function _DomainCollection_setSubDomainValues(domainKey, records, y, groupY, defaultValue) { + var _this6 = this; + this.get(domainKey).forEach(function (subDomain, index) { + var value = defaultValue; + if (records.hasOwnProperty(subDomain.t)) { + value = _this6.groupValues(__classPrivateFieldGet(_this6, _DomainCollection_instances, "m", _DomainCollection_extractValues).call(_this6, records[subDomain.t], y), groupY); + } + _this6.get(domainKey)[index].v = value; + }); +}, _DomainCollection_extractValues = function _DomainCollection_extractValues(data, y) { + return data.map(function (d) { + return typeof y === 'function' ? y(d) : d[y]; + }); +}, _DomainCollection_refreshKeys = function _DomainCollection_refreshKeys() { + this.keys = Array.from(this.collection.keys()).map(function (d) { + return parseInt(d, 10); + }).sort(function (a, b) { + return a - b; + }); + var keys = this.keys; + // eslint-disable-next-line prefer-destructuring + this.min = keys[0]; + this.max = keys[keys.length - 1]; + return this.keys; +}; + +var _DomainLabelPainter_instances, _DomainLabelPainter_textVerticalAlign, _DomainLabelPainter_getX, _DomainLabelPainter_getY, _DomainLabelPainter_getDomainInsideWidth, _DomainLabelPainter_getDomainInsideHeight, _DomainLabelPainter_domainRotate; +var DEFAULT_SELECTOR$2 = '.ch-domain-text'; +var DomainLabelPainter = /*#__PURE__*/function () { + function DomainLabelPainter(calendar) { + _classCallCheck(this, DomainLabelPainter); + _DomainLabelPainter_instances.add(this); + this.calendar = calendar; + } + _createClass(DomainLabelPainter, [{ + key: "paint", + value: function paint(root) { + var _this = this; + var _this$calendar$option = this.calendar.options.options.domain, + label = _this$calendar$option.label, + type = _this$calendar$option.type; + var dateHelper = this.calendar.dateHelper; + var format = label.text; + if (format === null || format === '') { + return; + } + if (typeof format === 'undefined') { + format = DOMAIN_FORMAT[type]; + } + root.selectAll(DEFAULT_SELECTOR$2).data(function (d) { + return [d]; + }, function (d) { + return d; + }).join(function (enter) { + return enter.append('text').attr('class', DEFAULT_SELECTOR$2.slice(1)).attr('x', function (d) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getX).call(_this, d); + }).attr('y', function (d) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getY).call(_this, d); + }).attr('text-anchor', label.textAlign).attr('dominant-baseline', function () { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_textVerticalAlign).call(_this); + }).text(function (d, i, nodes) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + dateHelper.format(d, format, nodes[i]) + ); + }).call(function (selection) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_domainRotate).call(_this, selection); + }); + }, function (update) { + update.attr('x', function (d) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getX).call(_this, d); + }).attr('y', function (d) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getY).call(_this, d); + }).attr('text-anchor', label.textAlign).attr('dominant-baseline', function () { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_textVerticalAlign).call(_this); + }).text(function (d, i, nodes) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + dateHelper.format(d, format, nodes[i]) + ); + }).call(function (selection) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_domainRotate).call(_this, selection); + }); + }); + } + }]); + return DomainLabelPainter; +}(); +_DomainLabelPainter_instances = new WeakSet(), _DomainLabelPainter_textVerticalAlign = function _DomainLabelPainter_textVerticalAlign() { + var _this$calendar$option2 = this.calendar.options.options.domain.label, + position = _this$calendar$option2.position, + rotate = _this$calendar$option2.rotate; + if (isVertical(position)) { + return 'middle'; + } + if (rotate === 'left' && position === 'left' || rotate === 'right' && position === 'right') { + return 'bottom'; + } + return 'hanging'; +}, _DomainLabelPainter_getX = function _DomainLabelPainter_getX(d) { + var _this$calendar$option3 = this.calendar.options.options.domain, + padding = _this$calendar$option3.padding, + _this$calendar$option4 = _this$calendar$option3.label, + position = _this$calendar$option4.position, + textAlign = _this$calendar$option4.textAlign, + offset = _this$calendar$option4.offset; + var domainHorizontalLabelWidth = this.calendar.options.options.x.domainHorizontalLabelWidth; + var x = padding[Position.LEFT]; + if (position === 'right') { + x += __classPrivateFieldGet(this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideWidth).call(this, d); + } + if (textAlign === 'middle') { + if (['top', 'bottom'].includes(position)) { + x += __classPrivateFieldGet(this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideWidth).call(this, d) / 2; + } else { + x += domainHorizontalLabelWidth / 2; + } + } + if (textAlign === 'end') { + if (isVertical(position)) { + x += __classPrivateFieldGet(this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideWidth).call(this, d); + } else { + x += domainHorizontalLabelWidth; + } + } + return x + offset.x; +}, _DomainLabelPainter_getY = function _DomainLabelPainter_getY(d) { + var _this$calendar$option5 = this.calendar.options.options, + _this$calendar$option6 = _this$calendar$option5.domain, + _this$calendar$option7 = _this$calendar$option6.label, + position = _this$calendar$option7.position, + offset = _this$calendar$option7.offset, + padding = _this$calendar$option6.padding, + x = _this$calendar$option5.x; + var y = padding[Position.TOP] + x.domainVerticalLabelHeight / 2; + if (position === 'bottom') { + y += __classPrivateFieldGet(this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideHeight).call(this, d); + } + return y + offset.y; +}, _DomainLabelPainter_getDomainInsideWidth = function _DomainLabelPainter_getDomainInsideWidth(d) { + var _this$calendar$option8 = this.calendar.options.options, + padding = _this$calendar$option8.domain.padding, + domainHorizontalLabelWidth = _this$calendar$option8.x.domainHorizontalLabelWidth; + var coordinates = this.calendar.calendarPainter.domainsContainerPainter.domainPainter.coordinates; + return coordinates.get(d).inner_width - domainHorizontalLabelWidth - horizontalPadding(padding); +}, _DomainLabelPainter_getDomainInsideHeight = function _DomainLabelPainter_getDomainInsideHeight(d) { + var _this$calendar$option9 = this.calendar.options.options, + domainVerticalLabelHeight = _this$calendar$option9.x.domainVerticalLabelHeight, + padding = _this$calendar$option9.domain.padding; + var coordinates = this.calendar.calendarPainter.domainsContainerPainter.domainPainter.coordinates; + return coordinates.get(d).inner_height - domainVerticalLabelHeight - verticalPadding(padding); +}, _DomainLabelPainter_domainRotate = function _DomainLabelPainter_domainRotate(selection) { + var _this2 = this; + var _this$calendar$option10 = this.calendar.options.options, + _this$calendar$option11 = _this$calendar$option10.domain.label, + rotate = _this$calendar$option11.rotate, + textAlign = _this$calendar$option11.textAlign, + position = _this$calendar$option11.position, + x = _this$calendar$option10.x; + var labelWidth = x.domainHorizontalLabelWidth; + switch (rotate) { + // Rotating the text clockwise + case 'right': + selection.attr('transform', function (d) { + var domainWidth = __classPrivateFieldGet(_this2, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideWidth).call(_this2, d); + var domainHeight = __classPrivateFieldGet(_this2, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideHeight).call(_this2, d); + var s = ["rotate(90, ".concat(position === 'right' ? domainWidth : labelWidth, ", 0)")]; + switch (position) { + case 'right': + if (textAlign === 'middle') { + s.push("translate(".concat(domainHeight / 2 - labelWidth / 2, ")")); + } else if (textAlign === 'end') { + s.push("translate(".concat(domainHeight - labelWidth, ")")); + } + break; + case 'left': + if (textAlign === 'start') { + s.push("translate(".concat(labelWidth, ")")); + } else if (textAlign === 'middle') { + s.push("translate(".concat(labelWidth / 2 + domainHeight / 2, ")")); + } else if (textAlign === 'end') { + s.push("translate(".concat(domainHeight, ")")); + } + break; + } + return s.join(','); + }); + break; + // Rotating the text anticlockwise + case 'left': + selection.attr('transform', function (d) { + var domainWidth = __classPrivateFieldGet(_this2, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideWidth).call(_this2, d); + var domainHeight = __classPrivateFieldGet(_this2, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideHeight).call(_this2, d); + var s = ["rotate(270, ".concat(position === 'right' ? domainWidth : labelWidth, ", 0)")]; + switch (position) { + case 'right': + if (textAlign === 'start') { + s.push("translate(-".concat(domainHeight, ")")); + } else if (textAlign === 'middle') { + s.push("translate(-".concat(domainHeight / 2 + labelWidth / 2, ")")); + } else if (textAlign === 'end') { + s.push("translate(-".concat(labelWidth, ")")); + } + break; + case 'left': + if (textAlign === 'start') { + s.push("translate(".concat(labelWidth - domainHeight, ")")); + } else if (textAlign === 'middle') { + s.push("translate(".concat(labelWidth / 2 - domainHeight / 2, ")")); + } + break; + } + return s.join(','); + }); + break; + } +}; + +// a string of all valid unicode whitespaces +var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + + '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + +var uncurryThis$8 = functionUncurryThis; +var requireObjectCoercible$3 = requireObjectCoercible$7; +var toString$5 = toString$9; +var whitespaces$1 = whitespaces$2; + +var replace$2 = uncurryThis$8(''.replace); +var ltrim = RegExp('^[' + whitespaces$1 + ']+'); +var rtrim = RegExp('(^|[^' + whitespaces$1 + '])[' + whitespaces$1 + ']+$'); + +// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation +var createMethod$1 = function (TYPE) { + return function ($this) { + var string = toString$5(requireObjectCoercible$3($this)); + if (TYPE & 1) string = replace$2(string, ltrim, ''); + if (TYPE & 2) string = replace$2(string, rtrim, '$1'); + return string; + }; +}; + +var stringTrim = { + // `String.prototype.{ trimLeft, trimStart }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimstart + start: createMethod$1(1), + // `String.prototype.{ trimRight, trimEnd }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimend + end: createMethod$1(2), + // `String.prototype.trim` method + // https://tc39.es/ecma262/#sec-string.prototype.trim + trim: createMethod$1(3) +}; + +var PROPER_FUNCTION_NAME = functionName.PROPER; +var fails$7 = fails$u; +var whitespaces = whitespaces$2; + +var non = '\u200B\u0085\u180E'; + +// check that a method works with the correct list +// of whitespaces and has a correct name +var stringTrimForced = function (METHOD_NAME) { + return fails$7(function () { + return !!whitespaces[METHOD_NAME]() + || non[METHOD_NAME]() !== non + || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME); + }); +}; + +var $$5 = _export; +var $trim = stringTrim.trim; +var forcedStringTrimMethod = stringTrimForced; + +// `String.prototype.trim` method +// https://tc39.es/ecma262/#sec-string.prototype.trim +$$5({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, { + trim: function trim() { + return $trim(this); + } +}); + +var _SubDomainPainter_instances, _SubDomainPainter_setPositions, _SubDomainPainter_classname, _SubDomainPainter_appendText, _SubDomainPainter_getCoordinates, _SubDomainPainter_getX, _SubDomainPainter_getY; +var DEFAULT_SELECTOR$1 = '.ch-subdomain'; +var HIGHLIGHT_CLASSNAME = 'highlight'; +var SubDomainPainter = /*#__PURE__*/function () { + function SubDomainPainter(calendar) { + _classCallCheck(this, SubDomainPainter); + _SubDomainPainter_instances.add(this); + this.calendar = calendar; + this.root = null; + } + _createClass(SubDomainPainter, [{ + key: "paint", + value: function paint(root) { + var _this = this; + this.root = root || this.root; + var containerClassname = "".concat(DEFAULT_SELECTOR$1, "-container"); + var subDomainSvgGroup = this.root.selectAll(containerClassname).data(function (d) { + return [d]; + }, function (d) { + return d; + }).join(function (enter) { + return enter.append('svg').call(function (selection) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_setPositions).call(_this, selection); + }).attr('class', containerClassname.slice(1)); + }, function (update) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + update.call(function (selection) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_setPositions).call(_this, selection); + }) + ); + }); + var _this$calendar$option = this.calendar.options.options.subDomain, + radius = _this$calendar$option.radius, + width = _this$calendar$option.width, + height = _this$calendar$option.height, + sort = _this$calendar$option.sort; + var evt = this.calendar.eventEmitter; + subDomainSvgGroup.selectAll('g').data(function (d) { + var subDomainsCollection = _this.calendar.domainCollection.get(d); + if (sort === 'desc') { + var max = Math.max.apply(Math, _toConsumableArray(subDomainsCollection.map(function (s) { + return s.x; + }))); + subDomainsCollection.forEach(function (s, i) { + subDomainsCollection[i].x = Math.abs(s.x - max); + }); + } + return subDomainsCollection; + }).join(function (enter) { + return enter.append('g').call(function (selection) { + return selection.insert('rect').attr('class', function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_classname).call(_this, d.t, "".concat(DEFAULT_SELECTOR$1.slice(1), "-bg")) + ); + }).attr('width', width).attr('height', height).attr('x', function (d) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_getX).call(_this, d); + }).attr('y', function (d) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_getY).call(_this, d); + }).on('click', function (ev, d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + evt.emit('click', ev, d.t, d.v) + ); + }).on('mouseover', function (ev, d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + evt.emit('mouseover', ev, d.t, d.v) + ); + }).on('mouseout', function (ev, d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + evt.emit('mouseout', ev, d.t, d.v) + ); + }).attr('rx', radius > 0 ? radius : null).attr('ry', radius > 0 ? radius : null); + }).call(function (selection) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_appendText).call(_this, selection); + }); + }, function (update) { + return update.selectAll('rect').attr('class', function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_classname).call(_this, d.t, "".concat(DEFAULT_SELECTOR$1.slice(1), "-bg")) + ); + }).attr('width', width).attr('height', height).attr('x', function (d) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_getX).call(_this, d); + }).attr('y', function (d) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_getY).call(_this, d); + }).attr('rx', radius).attr('ry', radius); + }); + } + }]); + return SubDomainPainter; +}(); +_SubDomainPainter_instances = new WeakSet(), _SubDomainPainter_setPositions = function _SubDomainPainter_setPositions(selection) { + var options = this.calendar.options.options; + var _options$domain = options.domain, + padding = _options$domain.padding, + position = _options$domain.label.position; + selection.attr('x', function () { + var pos = padding[Position.LEFT]; + if (position === 'left') { + pos += options.x.domainHorizontalLabelWidth; + } + return pos; + }).attr('y', function () { + var pos = padding[Position.TOP]; + if (position === 'top') { + pos += options.x.domainVerticalLabelHeight; + } + return pos; + }); +}, _SubDomainPainter_classname = function _SubDomainPainter_classname(timestamp) { + var _this2 = this; + var _this$calendar$option2 = this.calendar.options.options, + highlight = _this$calendar$option2.date.highlight, + type = _this$calendar$option2.subDomain.type; + var classname = ''; + if (highlight.length > 0) { + highlight.forEach(function (d) { + var unitFn = _this2.calendar.templateCollection.get(type).extractUnit; + if (unitFn(+d) === unitFn(timestamp)) { + classname = HIGHLIGHT_CLASSNAME; + } + }); + } + for (var _len = arguments.length, otherClasses = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + otherClasses[_key - 1] = arguments[_key]; + } + return [classname].concat(otherClasses).join(' ').trim(); +}, _SubDomainPainter_appendText = function _SubDomainPainter_appendText(elem) { + var _this3 = this; + var _this$calendar$option3 = this.calendar.options.options.subDomain, + width = _this$calendar$option3.width, + height = _this$calendar$option3.height, + label = _this$calendar$option3.label; + if (!label) { + return null; + } + return elem.append('text').attr('class', function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + __classPrivateFieldGet(_this3, _SubDomainPainter_instances, "m", _SubDomainPainter_classname).call(_this3, d.t, "".concat(DEFAULT_SELECTOR$1.slice(1), "-text")) + ); + }).attr('x', function (d) { + return __classPrivateFieldGet(_this3, _SubDomainPainter_instances, "m", _SubDomainPainter_getX).call(_this3, d) + width / 2; + }).attr('y', function (d) { + return __classPrivateFieldGet(_this3, _SubDomainPainter_instances, "m", _SubDomainPainter_getY).call(_this3, d) + height / 2; + }).attr('text-anchor', 'middle').attr('dominant-baseline', 'central').text(function (d, i, nodes) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + _this3.calendar.dateHelper.format(d.t, label, d.v, nodes[i]) + ); + }); +}, _SubDomainPainter_getCoordinates = function _SubDomainPainter_getCoordinates(axis, d) { + var subDomain = this.calendar.options.options.subDomain; + return d[axis] * (subDomain[axis === 'x' ? 'width' : 'height'] + subDomain.gutter); +}, _SubDomainPainter_getX = function _SubDomainPainter_getX(d) { + return __classPrivateFieldGet(this, _SubDomainPainter_instances, "m", _SubDomainPainter_getCoordinates).call(this, 'x', d); +}, _SubDomainPainter_getY = function _SubDomainPainter_getY(d) { + return __classPrivateFieldGet(this, _SubDomainPainter_instances, "m", _SubDomainPainter_getCoordinates).call(this, 'y', d); +}; + +var _DomainsContainerPainter_instances, _DomainsContainerPainter_startAnimation, _DomainsContainerPainter_endAnimation, _DomainsContainerPainter_recomputeDimensions; +var BASE_SELECTOR = '.ch-domain-container'; +var TRANSITION_CLASSNAME = 'in-transition'; +var DomainsContainerPainter = /*#__PURE__*/function () { + function DomainsContainerPainter(calendar) { + _classCallCheck(this, DomainsContainerPainter); + _DomainsContainerPainter_instances.add(this); + this.calendar = calendar; + this.domainPainter = new DomainPainter(calendar); + this.subDomainPainter = new SubDomainPainter(calendar); + this.domainLabelPainter = new DomainLabelPainter(calendar); + this.dimensions = { + width: 0, + height: 0 + }; + this.transitionsQueueCount = 0; + } + _createClass(DomainsContainerPainter, [{ + key: "setup", + value: function setup() { + this.root = this.calendar.calendarPainter.root.attr('x', 0).attr('y', 0).append('svg').attr('class', BASE_SELECTOR.slice(1)).append('svg').attr('class', "".concat(BASE_SELECTOR.slice(1), "-animation-wrapper")); + } + }, { + key: "paint", + value: function paint(scrollDirection) { + var _this = this; + __classPrivateFieldGet(this, _DomainsContainerPainter_instances, "m", _DomainsContainerPainter_startAnimation).call(this); + var result = this.domainPainter.paint(scrollDirection, this.root); + this.subDomainPainter.paint(this.domainPainter.root); + this.domainLabelPainter.paint(this.domainPainter.root); + __classPrivateFieldGet(this, _DomainsContainerPainter_instances, "m", _DomainsContainerPainter_recomputeDimensions).call(this); + Promise.allSettled(result).then(function () { + __classPrivateFieldGet(_this, _DomainsContainerPainter_instances, "m", _DomainsContainerPainter_endAnimation).call(_this); + }); + return result; + } + }, { + key: "updatePosition", + value: function updatePosition() { + var _a; + if (!((_a = this.root) === null || _a === void 0 ? void 0 : _a.node())) { + return Promise.resolve(); + } + var animationDuration = this.calendar.options.options.animationDuration; + var topHeight = this.calendar.pluginManager.getHeightFromPosition('top'); + var leftWidth = this.calendar.pluginManager.getWidthFromPosition('left'); + return [select(this.root.node().parentNode).transition().duration(animationDuration).call(function (selection) { + selection.attr('x', leftWidth).attr('y', topHeight); + }).end()]; + } + }, { + key: "width", + value: function width() { + return this.dimensions.width; + } + }, { + key: "height", + value: function height() { + return this.dimensions.height; + } + }, { + key: "destroy", + value: function destroy() { + __classPrivateFieldGet(this, _DomainsContainerPainter_instances, "m", _DomainsContainerPainter_startAnimation).call(this); + return Promise.resolve(); + } + }]); + return DomainsContainerPainter; +}(); +_DomainsContainerPainter_instances = new WeakSet(), _DomainsContainerPainter_startAnimation = function _DomainsContainerPainter_startAnimation() { + var _a; + if ((_a = this.root) === null || _a === void 0 ? void 0 : _a.node()) { + this.transitionsQueueCount += 1; + select(this.root.node().parentNode).classed(TRANSITION_CLASSNAME, true); + } +}, _DomainsContainerPainter_endAnimation = function _DomainsContainerPainter_endAnimation() { + var _a; + if ((_a = this.root) === null || _a === void 0 ? void 0 : _a.node()) { + this.transitionsQueueCount -= 1; + if (this.transitionsQueueCount === 0) { + select(this.root.node().parentNode).classed(TRANSITION_CLASSNAME, false); + } + } +}, _DomainsContainerPainter_recomputeDimensions = function _DomainsContainerPainter_recomputeDimensions() { + var _this$calendar$option = this.calendar.options.options, + animationDuration = _this$calendar$option.animationDuration, + verticalOrientation = _this$calendar$option.verticalOrientation, + gutter = _this$calendar$option.domain.gutter; + var domainsDimensions = this.domainPainter.dimensions; + this.dimensions = { + width: domainsDimensions.width - (verticalOrientation ? 0 : gutter), + height: domainsDimensions.height - (!verticalOrientation ? 0 : gutter) + }; + this.root.transition().duration(animationDuration).attr('width', this.dimensions.width).attr('height', this.dimensions.height); +}; + +var PluginPainter = /*#__PURE__*/function () { + function PluginPainter(calendar) { + _classCallCheck(this, PluginPainter); + this.calendar = calendar; + } + _createClass(PluginPainter, [{ + key: "paint", + value: function paint() { + var promises = []; + promises = promises.concat(this.calendar.pluginManager.paintAll()); + promises = promises.concat(this.setPluginsPosition()); + return promises; + } + }, { + key: "setPluginsPosition", + value: function setPluginsPosition() { + var pluginManager = this.calendar.pluginManager; + var animationDuration = this.calendar.options.options.animationDuration; + var domainsContainerPainter = this.calendar.calendarPainter.domainsContainerPainter; + var top = pluginManager.getFromPosition('top'); + var right = pluginManager.getFromPosition('right'); + var bottom = pluginManager.getFromPosition('bottom'); + var left = pluginManager.getFromPosition('left'); + var topHeight = pluginManager.getHeightFromPosition('top'); + var leftWidth = pluginManager.getWidthFromPosition('left'); + var promises = []; + var topOffset = 0; + top.forEach(function (plugin) { + promises.push(plugin.root.transition().duration(animationDuration).attr('y', topOffset).attr('x', leftWidth).end()); + topOffset += plugin.options.dimensions.height; + }); + var leftOffset = 0; + left.forEach(function (plugin) { + promises.push(plugin.root.transition().duration(animationDuration).attr('x', leftOffset).attr('y', topHeight).end()); + leftOffset += plugin.options.dimensions.width; + }); + bottom.forEach(function (plugin) { + promises.push(plugin.root.transition().duration(animationDuration).attr('x', leftWidth).attr('y', topHeight + domainsContainerPainter.height()).end()); + }); + leftOffset += domainsContainerPainter.width(); + right.forEach(function (plugin) { + promises.push(plugin.root.transition().duration(animationDuration).attr('x', leftOffset).attr('y', topHeight).end()); + leftOffset += plugin.options.dimensions.width; + }); + return promises; + } + }, { + key: "insideWidth", + value: function insideWidth() { + return this.calendar.pluginManager.getWidthFromPosition('left') + this.calendar.pluginManager.getWidthFromPosition('right'); + } + }, { + key: "insideHeight", + value: function insideHeight() { + return this.calendar.pluginManager.getHeightFromPosition('top') + this.calendar.pluginManager.getHeightFromPosition('bottom'); + } + }]); + return PluginPainter; +}(); + +var _CalendarPainter_instances, _CalendarPainter_getHeight, _CalendarPainter_getWidth, _CalendarPainter_resize; +var DEFAULT_SELECTOR = '.ch-container'; +var CalendarPainter = /*#__PURE__*/function () { + function CalendarPainter(calendar) { + _classCallCheck(this, CalendarPainter); + _CalendarPainter_instances.add(this); + this.calendar = calendar; + this.dimensions = { + width: 0, + height: 0 + }; + this.root = null; + this.domainsContainerPainter = new DomainsContainerPainter(calendar); + this.pluginPainter = new PluginPainter(calendar); + } + _createClass(CalendarPainter, [{ + key: "setup", + value: function setup() { + var _this$calendar$option = this.calendar.options.options, + itemSelector = _this$calendar$option.itemSelector, + theme = _this$calendar$option.theme; + if (!this.root) { + this.root = select(itemSelector).append('svg').attr('data-theme', theme).attr('class', DEFAULT_SELECTOR.slice(1)); + this.domainsContainerPainter.setup(); + } + this.calendar.pluginManager.setupAll(); + return true; + } + }, { + key: "paint", + value: function paint() { + var navigationDir = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ScrollDirection.SCROLL_NONE; + var transitions = this.domainsContainerPainter.paint(navigationDir).concat(this.pluginPainter.paint()).concat(this.domainsContainerPainter.updatePosition()); + __classPrivateFieldGet(this, _CalendarPainter_instances, "m", _CalendarPainter_resize).call(this); + return Promise.allSettled(transitions); + } + }, { + key: "destroy", + value: function destroy() { + var result = this.calendar.pluginManager.destroyAll().concat(this.domainsContainerPainter.destroy()); + if (!this.root) { + return Promise.allSettled(result); + } + result.push(this.root.transition().duration(this.calendar.options.options.animationDuration).attr('width', 0).attr('height', 0).remove().end()); + return Promise.allSettled(result); + } + }]); + return CalendarPainter; +}(); +_CalendarPainter_instances = new WeakSet(), _CalendarPainter_getHeight = function _CalendarPainter_getHeight() { + return this.domainsContainerPainter.height() + this.pluginPainter.insideHeight(); +}, _CalendarPainter_getWidth = function _CalendarPainter_getWidth() { + return this.domainsContainerPainter.width() + this.pluginPainter.insideWidth(); +}, _CalendarPainter_resize = function _CalendarPainter_resize() { + var options = this.calendar.options.options; + var newWidth = __classPrivateFieldGet(this, _CalendarPainter_instances, "m", _CalendarPainter_getWidth).call(this); + var newHeight = __classPrivateFieldGet(this, _CalendarPainter_instances, "m", _CalendarPainter_getHeight).call(this); + this.root.transition().duration(options.animationDuration).attr('width', newWidth).attr('height', newHeight); + if (newWidth !== this.dimensions.width || newHeight !== this.dimensions.height) { + this.calendar.eventEmitter.emit('resize', newWidth, newHeight, this.dimensions.width, this.dimensions.height); + } + this.dimensions = { + width: newWidth, + height: newHeight + }; +}; + +/** Detect free variable `global` from Node.js. */ +var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + +var freeGlobal$1 = freeGlobal; + +/** Detect free variable `self`. */ +var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + +/** Used as a reference to the global object. */ +var root = freeGlobal$1 || freeSelf || Function('return this')(); + +var root$1 = root; + +/** Built-in value references. */ +var Symbol$1 = root$1.Symbol; + +var Symbol$2 = Symbol$1; + +/** Used for built-in method references. */ +var objectProto$f = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty$c = objectProto$f.hasOwnProperty; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var nativeObjectToString$1 = objectProto$f.toString; + +/** Built-in value references. */ +var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined; + +/** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the raw `toStringTag`. + */ +function getRawTag(value) { + var isOwn = hasOwnProperty$c.call(value, symToStringTag$1), + tag = value[symToStringTag$1]; + + try { + value[symToStringTag$1] = undefined; + var unmasked = true; + } catch (e) {} + + var result = nativeObjectToString$1.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag$1] = tag; + } else { + delete value[symToStringTag$1]; + } + } + return result; +} + +/** Used for built-in method references. */ +var objectProto$e = Object.prototype; + +/** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ +var nativeObjectToString = objectProto$e.toString; + +/** + * Converts `value` to a string using `Object.prototype.toString`. + * + * @private + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + */ +function objectToString$1(value) { + return nativeObjectToString.call(value); +} + +/** `Object#toString` result references. */ +var nullTag = '[object Null]', + undefinedTag = '[object Undefined]'; + +/** Built-in value references. */ +var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : undefined; + +/** + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ +function baseGetTag(value) { + if (value == null) { + return value === undefined ? undefinedTag : nullTag; + } + return (symToStringTag && symToStringTag in Object(value)) + ? getRawTag(value) + : objectToString$1(value); +} + +/** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ +function isObject$2(value) { + var type = typeof value; + return value != null && (type == 'object' || type == 'function'); +} + +/** `Object#toString` result references. */ +var asyncTag = '[object AsyncFunction]', + funcTag$1 = '[object Function]', + genTag = '[object GeneratorFunction]', + proxyTag = '[object Proxy]'; + +/** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ +function isFunction(value) { + if (!isObject$2(value)) { + return false; + } + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 9 which returns 'object' for typed arrays and other constructors. + var tag = baseGetTag(value); + return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag; +} + +var $$4 = _export; +var toObject$1 = toObject$a; +var nativeKeys$2 = objectKeys$3; +var fails$6 = fails$u; + +var FAILS_ON_PRIMITIVES = fails$6(function () { nativeKeys$2(1); }); + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +$$4({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { + keys: function keys(it) { + return nativeKeys$2(toObject$1(it)); + } +}); + +var isObject$1 = isObject$j; +var classof$1 = classofRaw$2; +var wellKnownSymbol$3 = wellKnownSymbol$m; + +var MATCH$1 = wellKnownSymbol$3('match'); + +// `IsRegExp` abstract operation +// https://tc39.es/ecma262/#sec-isregexp +var isRegexp = function (it) { + var isRegExp; + return isObject$1(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$1(it) === 'RegExp'); +}; + +var isRegExp = isRegexp; + +var $TypeError$1 = TypeError; + +var notARegexp = function (it) { + if (isRegExp(it)) { + throw new $TypeError$1("The method doesn't accept regular expressions"); + } return it; +}; + +var wellKnownSymbol$2 = wellKnownSymbol$m; + +var MATCH = wellKnownSymbol$2('match'); + +var correctIsRegexpLogic = function (METHOD_NAME) { + var regexp = /./; + try { + '/./'[METHOD_NAME](regexp); + } catch (error1) { + try { + regexp[MATCH] = false; + return '/./'[METHOD_NAME](regexp); + } catch (error2) { /* empty */ } + } return false; +}; + +var $$3 = _export; +var uncurryThis$7 = functionUncurryThisClause; +var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; +var toLength$1 = toLength$3; +var toString$4 = toString$9; +var notARegExp$1 = notARegexp; +var requireObjectCoercible$2 = requireObjectCoercible$7; +var correctIsRegExpLogic$1 = correctIsRegexpLogic; + +// eslint-disable-next-line es/no-string-prototype-startswith -- safe +var nativeStartsWith = uncurryThis$7(''.startsWith); +var stringSlice$3 = uncurryThis$7(''.slice); +var min$1 = Math.min; + +var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic$1('startsWith'); +// https://github.com/zloirock/core-js/pull/702 +var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () { + var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith'); + return descriptor && !descriptor.writable; +}(); + +// `String.prototype.startsWith` method +// https://tc39.es/ecma262/#sec-string.prototype.startswith +$$3({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, { + startsWith: function startsWith(searchString /* , position = 0 */) { + var that = toString$4(requireObjectCoercible$2(this)); + notARegExp$1(searchString); + var index = toLength$1(min$1(arguments.length > 1 ? arguments[1] : undefined, that.length)); + var search = toString$4(searchString); + return nativeStartsWith + ? nativeStartsWith(that, search, index) + : stringSlice$3(that, index, index + search.length) === search; + } +}); + +var DESCRIPTORS$1 = descriptors; +var fails$5 = fails$u; +var uncurryThis$6 = functionUncurryThis; +var objectGetPrototypeOf = objectGetPrototypeOf$1; +var objectKeys = objectKeys$3; +var toIndexedObject = toIndexedObject$9; +var $propertyIsEnumerable = objectPropertyIsEnumerable.f; + +var propertyIsEnumerable$2 = uncurryThis$6($propertyIsEnumerable); +var push$1 = uncurryThis$6([].push); + +// in some IE versions, `propertyIsEnumerable` returns incorrect result on integer keys +// of `null` prototype objects +var IE_BUG = DESCRIPTORS$1 && fails$5(function () { + // eslint-disable-next-line es/no-object-create -- safe + var O = Object.create(null); + O[2] = 2; + return !propertyIsEnumerable$2(O, 2); +}); + +// `Object.{ entries, values }` methods implementation +var createMethod = function (TO_ENTRIES) { + return function (it) { + var O = toIndexedObject(it); + var keys = objectKeys(O); + var IE_WORKAROUND = IE_BUG && objectGetPrototypeOf(O) === null; + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!DESCRIPTORS$1 || (IE_WORKAROUND ? key in O : propertyIsEnumerable$2(O, key))) { + push$1(result, TO_ENTRIES ? [key, O[key]] : O[key]); + } + } + return result; + }; +}; + +var objectToArray = { + // `Object.entries` method + // https://tc39.es/ecma262/#sec-object.entries + entries: createMethod(true), + // `Object.values` method + // https://tc39.es/ecma262/#sec-object.values + values: createMethod(false) +}; + +var $$2 = _export; +var $entries = objectToArray.entries; + +// `Object.entries` method +// https://tc39.es/ecma262/#sec-object.entries +$$2({ target: 'Object', stat: true }, { + entries: function entries(O) { + return $entries(O); + } +}); + +function defined(x) { + return x != null && !Number.isNaN(x); +} + +function ascendingDefined(a, b) { + return +defined(b) - +defined(a) || ascending(a, b); +} + +function finite(x) { + return isFinite(x) ? x : NaN; +} + +function positive(x) { + return x > 0 && isFinite(x) ? x : NaN; +} + +function negative(x) { + return x < 0 && isFinite(x) ? x : NaN; +} + +const re = /^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/; + +function parse(string, fallback) { + if (!re.test(string += "")) return typeof fallback === "function" ? fallback(string) : fallback; + return new Date(string); +} + +const timeIntervals = new Map([ + ["second", timeSecond], + ["minute", timeMinute], + ["hour", timeHour], + ["day", timeDay], + ["week", timeWeek], + ["month", timeMonth], + ["quarter", timeMonth.every(3)], + ["half", timeMonth.every(6)], + ["year", timeYear], + ["monday", timeMonday], + ["tuesday", timeTuesday], + ["wednesday", timeWednesday], + ["thursday", timeThursday], + ["friday", timeFriday], + ["saturday", timeSaturday], + ["sunday", timeSunday] +]); + +const utcIntervals = new Map([ + ["second", utcSecond], + ["minute", utcMinute], + ["hour", utcHour], + ["day", utcDay], + ["week", utcWeek], + ["month", utcMonth], + ["quarter", utcMonth.every(3)], + ["half", utcMonth.every(6)], + ["year", utcYear], + ["monday", utcMonday], + ["tuesday", utcTuesday], + ["wednesday", utcWednesday], + ["thursday", utcThursday], + ["friday", utcFriday], + ["saturday", utcSaturday], + ["sunday", utcSunday] +]); + +function maybeTimeInterval(interval) { + const i = timeIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; +} + +function maybeUtcInterval(interval) { + const i = utcIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; +} + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray +const TypedArray = Object.getPrototypeOf(Uint8Array); +const objectToString = Object.prototype.toString; +const constant$1 = (x) => () => x; + +// If the values are specified as a typed array, no coercion is required. +function coerceNumbers(values) { + return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array); +} + +// Unlike Mark’s number, here we want to convert null and undefined to NaN since +// the result will be stored in a Float64Array and we don’t want null to be +// coerced to zero. We use Number instead of unary + to allow BigInt coercion. +function coerceNumber(x) { + return x == null ? NaN : Number(x); +} + +function coerceDates(values) { + return map(values, coerceDate); +} + +// When coercing strings to dates, we only want to allow the ISO 8601 format +// since the built-in string parsing of the Date constructor varies across +// browsers. (In the future, this could be made more liberal if desired, though +// it is still generally preferable to do date parsing yourself explicitly, +// rather than rely on Plot.) Any non-string values are coerced to number first +// and treated as milliseconds since UNIX epoch. +function coerceDate(x) { + return x instanceof Date && !isNaN(x) + ? x + : typeof x === "string" + ? parse(x) + : x == null || isNaN((x = +x)) + ? undefined + : new Date(x); +} + +// Promotes the specified data to an array as needed. +function arrayify(data) { + return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data); +} + +// An optimization of type.from(values, f): if the given values are already an +// instanceof the desired array type, the faster values.map method is used. +function map(values, f, type = Array) { + return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f); +} + +// An optimization of type.from(values): if the given values are already an +// instanceof the desired array type, the faster values.slice method is used. +function slice(values, type = Array) { + return values instanceof type ? values.slice() : type.from(values); +} + +// Disambiguates an options object (e.g., {y: "x2"}) from a primitive value. +function isObject(option) { + return option?.toString === objectToString; +} + +// Disambiguates a scale options object (e.g., {color: {type: "linear"}}) from +// some other option (e.g., {color: "red"}). When creating standalone legends, +// this is used to test whether a scale is defined; this should be consistent +// with inferScaleType when there are no channels associated with the scale, and +// if this returns true, then normalizeScale must return non-null. +function isScaleOptions(option) { + return isObject(option) && (option.type !== undefined || option.domain !== undefined); +} + +// If interval is not nullish, converts interval shorthand such as a number (for +// multiples) or a time interval name (such as “day”) to a {floor, offset, +// range} object similar to a D3 time interval. +function maybeInterval(interval, type) { + if (interval == null) return; + if (typeof interval === "number") { + if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval; + const n = Math.abs(interval); + return interval < 0 + ? { + floor: (d) => Math.floor(d * n) / n, + offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity + range: (lo, hi) => range(Math.ceil(lo * n), hi * n).map((x) => x / n) + } + : { + floor: (d) => Math.floor(d / n) * n, + offset: (d) => d + n, // note: no optional step for simplicity + range: (lo, hi) => range(Math.ceil(lo / n), hi / n).map((x) => x * n) + }; + } + if (typeof interval === "string") return (type === "time" ? maybeTimeInterval : maybeUtcInterval)(interval); + if (typeof interval.floor !== "function") throw new Error("invalid interval; missing floor method"); + if (typeof interval.offset !== "function") throw new Error("invalid interval; missing offset method"); + return interval; +} + +// Like maybeInterval, but requires a range method too. +function maybeRangeInterval(interval, type) { + interval = maybeInterval(interval, type); + if (interval && typeof interval.range !== "function") throw new Error("invalid interval: missing range method"); + return interval; +} + +// Like maybeRangeInterval, but requires a ceil method too. +function maybeNiceInterval(interval, type) { + interval = maybeRangeInterval(interval, type); + if (interval && typeof interval.ceil !== "function") throw new Error("invalid interval: missing ceil method"); + return interval; +} + +function isOrdinal(values) { + for (const value of values) { + if (value == null) continue; + const type = typeof value; + return type === "string" || type === "boolean"; + } +} + +function isTemporal(values) { + for (const value of values) { + if (value == null) continue; + return value instanceof Date; + } +} + +// Are these strings that might represent dates? This is stricter than ISO 8601 +// because we want to ignore false positives on numbers; for example, the string +// "1192" is more likely to represent a number than a date even though it is +// valid ISO 8601 representing 1192-01-01. +function isTemporalString(values) { + for (const value of values) { + if (value == null) continue; + return typeof value === "string" && isNaN(value) && parse(value); + } +} + +// Are these strings that might represent numbers? This is stricter than +// coercion because we want to ignore false positives on e.g. empty strings. +function isNumericString(values) { + for (const value of values) { + if (value == null) continue; + if (typeof value !== "string") return false; + if (!value.trim()) continue; + return !isNaN(value); + } +} + +function isNoneish(value) { + return value == null || isNone(value); +} + +function isNone(value) { + return /^\s*none\s*$/i.test(value); +} + +// Like a sort comparator, returns a positive value if the given array of values +// is in ascending order, a negative value if the values are in descending +// order. Assumes monotonicity; only tests the first and last values. +function orderof(values) { + if (values == null) return; + const first = values[0]; + const last = values[values.length - 1]; + return descending(first, last); +} + +// Positional scales have associated axes, and for ordinal data, a point or band +// scale is used instead of an ordinal scale. +const position = Symbol("position"); + +// Color scales default to the turbo interpolator for quantitative data, and to +// the Tableau10 scheme for ordinal data. Color scales may also have an +// associated legend. +const color = Symbol("color"); + +// Radius scales default to the sqrt type, have a default range of [0, 3], and a +// default domain from 0 to the median first quartile of associated channels. +const radius = Symbol("radius"); + +// Length scales default to the linear type, have a default range of [0, 12], +// and a default domain from 0 to the median median of associated channels. +const length = Symbol("length"); + +// Opacity scales have a default range of [0, 1], and a default domain from 0 to +// the maximum value of associated channels. +const opacity = Symbol("opacity"); + +// Symbol scales have a default range of categorical symbols. +const symbol = Symbol("symbol"); + +// TODO Rather than hard-coding the list of known scale names, collect the names +// and categories for each plot specification, so that custom marks can register +// custom scales. +const registry = new Map([ + ["x", position], + ["y", position], + ["fx", position], + ["fy", position], + ["r", radius], + ["color", color], + ["opacity", opacity], + ["symbol", symbol], + ["length", length] +]); + +const sqrt3 = Math.sqrt(3); +const sqrt4_3 = 2 / sqrt3; + +const symbolHexagon = { + draw(context, size) { + const rx = Math.sqrt(size / Math.PI), + ry = rx * sqrt4_3, + hy = ry / 2; + context.moveTo(0, ry); + context.lineTo(rx, hy); + context.lineTo(rx, -hy); + context.lineTo(0, -ry); + context.lineTo(-rx, -hy); + context.lineTo(-rx, hy); + context.closePath(); + } +}; + +const symbols = new Map([ + ["asterisk", symbolAsterisk], + ["circle", symbolCircle], + ["cross", symbolCross], + ["diamond", symbolDiamond], + ["diamond2", symbolDiamond2], + ["hexagon", symbolHexagon], + ["plus", symbolPlus], + ["square", symbolSquare], + ["square2", symbolSquare2], + ["star", symbolStar], + ["times", symbolTimes], + ["triangle", symbolTriangle], + ["triangle2", symbolTriangle2], + ["wye", symbolWye] +]); + +function isSymbolObject(value) { + return value && typeof value.draw === "function"; +} + +function maybeSymbol(symbol) { + if (symbol == null || isSymbolObject(symbol)) return symbol; + const value = symbols.get(`${symbol}`.toLowerCase()); + if (value) return value; + throw new Error(`invalid symbol: ${symbol}`); +} + +function warn(message) { + console.warn(message); +} + +const ordinalSchemes = new Map([ + // categorical + ["accent", schemeAccent], + ["category10", schemeCategory10], + ["dark2", schemeDark2], + ["paired", schemePaired], + ["pastel1", schemePastel1], + ["pastel2", schemePastel2], + ["set1", schemeSet1], + ["set2", schemeSet2], + ["set3", schemeSet3], + ["tableau10", schemeTableau10], + + // diverging + ["brbg", scheme11(schemeBrBG, interpolateBrBG)], + ["prgn", scheme11(schemePRGn, interpolatePRGn)], + ["piyg", scheme11(schemePiYG, interpolatePiYG)], + ["puor", scheme11(schemePuOr, interpolatePuOr)], + ["rdbu", scheme11(schemeRdBu, interpolateRdBu)], + ["rdgy", scheme11(schemeRdGy, interpolateRdGy)], + ["rdylbu", scheme11(schemeRdYlBu, interpolateRdYlBu)], + ["rdylgn", scheme11(schemeRdYlGn, interpolateRdYlGn)], + ["spectral", scheme11(schemeSpectral, interpolateSpectral)], + + // reversed diverging (for temperature data) + ["burd", scheme11r(schemeRdBu, interpolateRdBu)], + ["buylrd", scheme11r(schemeRdYlBu, interpolateRdYlBu)], + + // sequential (single-hue) + ["blues", scheme9(schemeBlues, interpolateBlues)], + ["greens", scheme9(schemeGreens, interpolateGreens)], + ["greys", scheme9(schemeGreys, interpolateGreys)], + ["oranges", scheme9(schemeOranges, interpolateOranges)], + ["purples", scheme9(schemePurples, interpolatePurples)], + ["reds", scheme9(schemeReds, interpolateReds)], + + // sequential (multi-hue) + ["turbo", schemei(interpolateTurbo)], + ["viridis", schemei(interpolateViridis)], + ["magma", schemei(interpolateMagma)], + ["inferno", schemei(interpolateInferno)], + ["plasma", schemei(interpolatePlasma)], + ["cividis", schemei(interpolateCividis)], + ["cubehelix", schemei(interpolateCubehelixDefault)], + ["warm", schemei(interpolateWarm)], + ["cool", schemei(interpolateCool)], + ["bugn", scheme9(schemeBuGn, interpolateBuGn)], + ["bupu", scheme9(schemeBuPu, interpolateBuPu)], + ["gnbu", scheme9(schemeGnBu, interpolateGnBu)], + ["orrd", scheme9(schemeOrRd, interpolateOrRd)], + ["pubu", scheme9(schemePuBu, interpolatePuBu)], + ["pubugn", scheme9(schemePuBuGn, interpolatePuBuGn)], + ["purd", scheme9(schemePuRd, interpolatePuRd)], + ["rdpu", scheme9(schemeRdPu, interpolateRdPu)], + ["ylgn", scheme9(schemeYlGn, interpolateYlGn)], + ["ylgnbu", scheme9(schemeYlGnBu, interpolateYlGnBu)], + ["ylorbr", scheme9(schemeYlOrBr, interpolateYlOrBr)], + ["ylorrd", scheme9(schemeYlOrRd, interpolateYlOrRd)], + + // cyclical + ["rainbow", schemeicyclical(interpolateRainbow)], + ["sinebow", schemeicyclical(interpolateSinebow)] +]); + +function scheme9(scheme, interpolate) { + return ({length: n}) => { + if (n === 1) return [scheme[3][1]]; // favor midpoint + if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker + n = Math.max(3, Math.floor(n)); + return n > 9 ? quantize(interpolate, n) : scheme[n]; + }; +} + +function scheme11(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? quantize(interpolate, n) : scheme[n]; + }; +} + +function scheme11r(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse(); + }; +} + +function schemei(interpolate) { + return ({length: n}) => quantize(interpolate, Math.max(2, Math.floor(n))); +} + +function schemeicyclical(interpolate) { + return ({length: n}) => quantize(interpolate, Math.floor(n) + 1).slice(0, -1); +} + +function ordinalScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`); + return ordinalSchemes.get(s); +} + +function ordinalRange(scheme, length) { + const s = ordinalScheme(scheme); + const r = typeof s === "function" ? s({length}) : s; + return r.length !== length ? r.slice(0, length) : r; +} + +// If the specified domain contains only booleans (ignoring null and undefined), +// returns a corresponding range where false is mapped to the low color and true +// is mapped to the high color of the specified scheme. +function maybeBooleanRange(domain, scheme = "greys") { + const range = new Set(); + const [f, t] = ordinalRange(scheme, 2); + for (const value of domain) { + if (value == null) continue; + if (value === true) range.add(t); + else if (value === false) range.add(f); + else return; + } + return [...range]; +} + +const quantitativeSchemes = new Map([ + // diverging + ["brbg", interpolateBrBG], + ["prgn", interpolatePRGn], + ["piyg", interpolatePiYG], + ["puor", interpolatePuOr], + ["rdbu", interpolateRdBu], + ["rdgy", interpolateRdGy], + ["rdylbu", interpolateRdYlBu], + ["rdylgn", interpolateRdYlGn], + ["spectral", interpolateSpectral], + + // reversed diverging (for temperature data) + ["burd", (t) => interpolateRdBu(1 - t)], + ["buylrd", (t) => interpolateRdYlBu(1 - t)], + + // sequential (single-hue) + ["blues", interpolateBlues], + ["greens", interpolateGreens], + ["greys", interpolateGreys], + ["purples", interpolatePurples], + ["reds", interpolateReds], + ["oranges", interpolateOranges], + + // sequential (multi-hue) + ["turbo", interpolateTurbo], + ["viridis", interpolateViridis], + ["magma", interpolateMagma], + ["inferno", interpolateInferno], + ["plasma", interpolatePlasma], + ["cividis", interpolateCividis], + ["cubehelix", interpolateCubehelixDefault], + ["warm", interpolateWarm], + ["cool", interpolateCool], + ["bugn", interpolateBuGn], + ["bupu", interpolateBuPu], + ["gnbu", interpolateGnBu], + ["orrd", interpolateOrRd], + ["pubugn", interpolatePuBuGn], + ["pubu", interpolatePuBu], + ["purd", interpolatePuRd], + ["rdpu", interpolateRdPu], + ["ylgnbu", interpolateYlGnBu], + ["ylgn", interpolateYlGn], + ["ylorbr", interpolateYlOrBr], + ["ylorrd", interpolateYlOrRd], + + // cyclical + ["rainbow", interpolateRainbow], + ["sinebow", interpolateSinebow] +]); + +function quantitativeScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`); + return quantitativeSchemes.get(s); +} + +const divergingSchemes = new Set([ + "brbg", + "prgn", + "piyg", + "puor", + "rdbu", + "rdgy", + "rdylbu", + "rdylgn", + "spectral", + "burd", + "buylrd" +]); + +function isDivergingScheme(scheme) { + return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase()); +} + +const flip = (i) => (t) => i(1 - t); +const unit = [0, 1]; + +const interpolators = new Map([ + // numbers + ["number", interpolateNumber], + + // color spaces + ["rgb", interpolateRgb], + ["hsl", interpolateHsl], + ["hcl", interpolateHcl], + ["lab", interpolateLab] +]); + +function maybeInterpolator(interpolate) { + const i = `${interpolate}`.toLowerCase(); + if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`); + return interpolators.get(i); +} + +function createScaleQ( + key, + scale, + channels, + { + type, + nice, + clamp, + zero, + domain = inferAutoDomain(key, channels), + unknown, + round, + scheme, + interval, + range = registry.get(key) === radius + ? inferRadialRange(channels, domain) + : registry.get(key) === length + ? inferLengthRange(channels, domain) + : registry.get(key) === opacity + ? unit + : undefined, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : type === "cyclical" ? "rainbow" : "turbo") + : round + ? interpolateRound + : interpolateNumber, + reverse: reverse$1 + } +) { + interval = maybeRangeInterval(interval, type); + if (type === "cyclical" || type === "sequential") type = "linear"; // shorthand for color schemes + reverse$1 = !!reverse$1; + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + if (interpolate.length === 1) { + if (reverse$1) { + interpolate = flip(interpolate); + reverse$1 = false; + } + if (range === undefined) { + range = Float64Array.from(domain, (_, i) => i / (domain.length - 1)); + if (range.length === 2) range = unit; // optimize common case of [0, 1] + } + scale.interpolate((range === unit ? constant$1 : interpolatePiecewise)(interpolate)); + } else { + scale.interpolate(interpolate); + } + + // If a zero option is specified, we assume that the domain is numeric, and we + // want to ensure that the domain crosses zero. However, note that the domain + // may be reversed (descending) so we shouldn’t assume that the first value is + // smaller than the last; and also it’s possible that the domain has more than + // two values for a “poly” scale. And lastly be careful not to mutate input! + if (zero) { + const [min, max] = extent(domain); + if (min > 0 || max < 0) { + domain = slice(domain); + if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0; + // [2, 1] or [-2, -1] + else domain[0] = 0; // [1, 2] or [-1, -2] + } + } + + if (reverse$1) domain = reverse(domain); + scale.domain(domain).unknown(unknown); + if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain()); + if (range !== undefined) scale.range(range); + if (clamp) scale.clamp(clamp); + return {type, domain, range, scale, interpolate, interval}; +} + +function maybeNice(nice, type) { + return nice === true ? undefined : typeof nice === "number" ? nice : maybeNiceInterval(nice, type); +} + +function createScaleLinear(key, channels, options) { + return createScaleQ(key, scaleLinear(), channels, options); +} + +function createScaleSqrt(key, channels, options) { + return createScalePow(key, channels, {...options, exponent: 0.5}); +} + +function createScalePow(key, channels, {exponent = 1, ...options}) { + return createScaleQ(key, scalePow().exponent(exponent), channels, {...options, type: "pow"}); +} + +function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) { + return createScaleQ(key, scaleLog().base(base), channels, {...options, domain}); +} + +function createScaleSymlog(key, channels, {constant = 1, ...options}) { + return createScaleQ(key, scaleSymlog().constant(constant), channels, options); +} + +function createScaleQuantile( + key, + channels, + { + range, + quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead + n = quantiles, + scheme = "rdylbu", + domain = inferQuantileDomain(channels), + unknown, + interpolate, + reverse + } +) { + if (range === undefined) { + range = + interpolate !== undefined + ? quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } + if (domain.length > 0) { + domain = scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles(); + } + return createScaleThreshold(key, channels, {domain, range, reverse, unknown}); +} + +function createScaleQuantize( + key, + channels, + { + range, + n = range === undefined ? 5 : (range = [...range]).length, + scheme = "rdylbu", + domain = inferAutoDomain(key, channels), + unknown, + interpolate, + reverse + } +) { + const [min, max] = extent(domain); + let thresholds; + if (range === undefined) { + thresholds = ticks(min, max, n); // approximate number of nice, round thresholds + if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound + if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound + n = thresholds.length + 1; + range = + interpolate !== undefined + ? quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } else { + thresholds = quantize(interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range + if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types + } + if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain + return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown}); +} + +function createScaleThreshold( + key, + channels, + { + domain = [0], // explicit thresholds in ascending order + unknown, + scheme = "rdylbu", + interpolate, + range = interpolate !== undefined + ? quantize(interpolate, domain.length + 1) + : registry.get(key) === color + ? ordinalRange(scheme, domain.length + 1) + : undefined, + reverse: reverse$1 + } +) { + domain = arrayify(domain); + const sign = orderof(domain); // preserve descending domain + if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`); + if (reverse$1) range = reverse(range); // domain ascending, so reverse range + return { + type: "threshold", + scale: scaleThreshold(sign < 0 ? reverse(domain) : domain, range === undefined ? [] : range).unknown(unknown), + domain, + range + }; +} + +function isOrdered(domain, sign) { + for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) { + const s = descending(d, (d = domain[i])); + if (s !== 0 && s !== sign) return false; + } + return true; +} + +function createScaleIdentity() { + return {type: "identity", scale: scaleIdentity()}; +} + +function inferDomain$1(channels, f = finite) { + return channels.length + ? [ + min$4(channels, ({value}) => (value === undefined ? value : min$4(value, f))), + max$4(channels, ({value}) => (value === undefined ? value : max$4(value, f))) + ] + : [0, 1]; +} + +function inferAutoDomain(key, channels) { + const type = registry.get(key); + return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain$1)(channels); +} + +function inferZeroDomain(channels) { + return [0, channels.length ? max$4(channels, ({value}) => (value === undefined ? value : max$4(value, finite))) : 1]; +} + +// We don’t want the upper bound of the radial domain to be zero, as this would +// be degenerate, so we ignore nonpositive values. We also don’t want the +// maximum default radius to exceed 30px. +function inferRadialRange(channels, domain) { + const hint = channels.find(({radius}) => radius !== undefined); + if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins + const h25 = quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : quantile(value, 0.25, positive))); + const range = domain.map((d) => 3 * Math.sqrt(d / h25)); + const k = 30 / max$4(range); + return k < 1 ? range.map((r) => r * k) : range; +} + +// We want a length scale’s domain to go from zero to a positive value, and to +// treat negative lengths if any as inverted vectors of equivalent magnitude. We +// also don’t want the maximum default length to exceed 60px. +function inferLengthRange(channels, domain) { + const h50 = median(channels, ({value}) => (value === undefined ? NaN : median(value, Math.abs))); + const range = domain.map((d) => (12 * d) / h50); + const k = 60 / max$4(range); + return k < 1 ? range.map((r) => r * k) : range; +} + +function inferLogDomain(channels) { + for (const {value} of channels) { + if (value !== undefined) { + for (let v of value) { + if (v > 0) return inferDomain$1(channels, positive); + if (v < 0) return inferDomain$1(channels, negative); + } + } + } + return [1, 10]; +} + +function inferQuantileDomain(channels) { + const domain = []; + for (const {value} of channels) { + if (value === undefined) continue; + for (const v of value) domain.push(v); + } + return domain; +} + +function interpolatePiecewise(interpolate) { + return (i, j) => (t) => interpolate(i + t * (j - i)); +} + +function createScaleD( + key, + scale, + transform, + channels, + { + type, + nice, + clamp, + domain = inferDomain$1(channels), + unknown, + pivot = 0, + scheme, + range, + symmetric = true, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : "rdbu") + : interpolateNumber, + reverse + } +) { + pivot = +pivot; + let [min, max] = domain; + if (descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse); + min = Math.min(min, pivot); + max = Math.max(max, pivot); + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + + // If an explicit range is specified, promote it to a piecewise interpolator. + if (range !== undefined) { + interpolate = + interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : piecewise(interpolate, range); + } + + // Reverse before normalization. + if (reverse) interpolate = flip(interpolate); + + // Normalize the interpolator for symmetric difference around the pivot. + if (symmetric) { + const mid = transform.apply(pivot); + const mindelta = mid - transform.apply(min); + const maxdelta = transform.apply(max) - mid; + if (mindelta < maxdelta) min = transform.invert(mid - maxdelta); + else if (mindelta > maxdelta) max = transform.invert(mid + mindelta); + } + + scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate); + if (clamp) scale.clamp(clamp); + if (nice) scale.nice(nice); + return {type, domain: [min, max], pivot, interpolate, scale}; +} + +function createScaleDiverging(key, channels, options) { + return createScaleD(key, scaleDiverging(), transformIdentity, channels, options); +} + +function createScaleDivergingSqrt(key, channels, options) { + return createScaleDivergingPow(key, channels, {...options, exponent: 0.5}); +} + +function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) { + return createScaleD(key, scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, { + ...options, + type: "diverging-pow" + }); +} + +function createScaleDivergingLog( + key, + channels, + {base = 10, pivot = 1, domain = inferDomain$1(channels, pivot < 0 ? negative : positive), ...options} +) { + return createScaleD(key, scaleDivergingLog().base((base = +base)), transformLog, channels, { + domain, + pivot, + ...options + }); +} + +function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) { + return createScaleD( + key, + scaleDivergingSymlog().constant((constant = +constant)), + transformSymlog(constant), + channels, + options + ); +} + +const transformIdentity = { + apply(x) { + return x; + }, + invert(x) { + return x; + } +}; + +const transformLog = { + apply: Math.log, + invert: Math.exp +}; + +const transformSqrt = { + apply(x) { + return Math.sign(x) * Math.sqrt(Math.abs(x)); + }, + invert(x) { + return Math.sign(x) * (x * x); + } +}; + +function transformPow(exponent) { + return exponent === 0.5 + ? transformSqrt + : { + apply(x) { + return Math.sign(x) * Math.pow(Math.abs(x), exponent); + }, + invert(x) { + return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent); + } + }; +} + +function transformSymlog(constant) { + return { + apply(x) { + return Math.sign(x) * Math.log1p(Math.abs(x / constant)); + }, + invert(x) { + return Math.sign(x) * Math.expm1(Math.abs(x)) * constant; + } + }; +} + +function createScaleT(key, scale, channels, options) { + return createScaleQ(key, scale, channels, options); +} + +function createScaleTime(key, channels, options) { + return createScaleT(key, scaleTime(), channels, options); +} + +function createScaleUtc(key, channels, options) { + return createScaleT(key, scaleUtc(), channels, options); +} + +// This denotes an implicitly ordinal color scale: the scale type was not set, +// but the associated values are strings or booleans. If the associated defined +// values are entirely boolean, the range will default to greys. You can opt out +// of this by setting the type explicitly. +const ordinalImplicit = Symbol("ordinal"); + +function createScaleO(key, scale, channels, {type, interval, domain, range, reverse: reverse$1, hint}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + if (type === "categorical" || type === ordinalImplicit) type = "ordinal"; // shorthand for color schemes + if (reverse$1) domain = reverse(domain); + scale.domain(domain); + if (range !== undefined) { + // If the range is specified as a function, pass it the domain. + if (typeof range === "function") range = range(domain); + scale.range(range); + } + return {type, domain, range, scale, hint, interval}; +} + +function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + let hint; + if (registry.get(key) === symbol) { + hint = inferSymbolHint(channels); + range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol); + } else if (registry.get(key) === color) { + if (range === undefined && (type === "ordinal" || type === ordinalImplicit)) { + range = maybeBooleanRange(domain, scheme); + if (range !== undefined) scheme = undefined; // Don’t re-apply scheme. + } + if (scheme === undefined && range === undefined) { + scheme = type === "ordinal" ? "turbo" : "tableau10"; + } + if (scheme !== undefined) { + if (range !== undefined) { + const interpolate = quantitativeScheme(scheme); + const t0 = range[0], + d = range[1] - range[0]; + range = ({length: n}) => quantize((t) => interpolate(t0 + d * t), n); + } else { + range = ordinalScheme(scheme); + } + } + } + if (unknown === scaleImplicit) { + throw new Error(`implicit unknown on ${key} scale is not supported`); + } + return createScaleO(key, scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint}); +} + +function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) { + return maybeRound(scalePoint().align(align).padding(padding), channels, options, key); +} + +function createScaleBand( + key, + channels, + { + align = 0.5, + padding = 0.1, + paddingInner = padding, + paddingOuter = key === "fx" || key === "fy" ? 0 : padding, + ...options + } +) { + return maybeRound( + scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter), + channels, + options, + key + ); +} + +function maybeRound(scale, channels, options, key) { + let {round} = options; + if (round !== undefined) scale.round((round = !!round)); + scale = createScaleO(key, scale, channels, options); + scale.round = round; // preserve for autoScaleRound + return scale; +} + +function inferDomain(channels, interval, key) { + const values = new InternSet(); + for (const {value, domain} of channels) { + if (domain !== undefined) return domain(); // see channelDomain + if (value === undefined) continue; + for (const v of value) values.add(v); + } + if (interval !== undefined) { + const [min, max] = extent(values).map(interval.floor, interval); + return interval.range(min, interval.offset(max)); + } + if (values.size > 10e3 && registry.get(key) === position) { + throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`); + } + return sort(values, ascendingDefined); +} + +// If all channels provide a consistent hint, propagate it to the scale. +function inferHint(channels, key) { + let value; + for (const {hint} of channels) { + const candidate = hint?.[key]; + if (candidate === undefined) continue; // no hint here + if (value === undefined) value = candidate; + // first hint + else if (value !== candidate) return; // inconsistent hint + } + return value; +} + +function inferSymbolHint(channels) { + return { + fill: inferHint(channels, "fill"), + stroke: inferHint(channels, "stroke") + }; +} + +function inferSymbolRange(hint) { + return isNoneish(hint.fill) ? symbolsStroke : symbolsFill; +} + +function normalizeScale(key, scale, hint) { + return createScale(key, hint === undefined ? undefined : [{hint}], {...scale}); +} + +function createScale(key, channels = [], options = {}) { + const type = inferScaleType(key, channels, options); + + // Warn for common misuses of implicit ordinal scales. We disable this test if + // you specify a scale interval or if you set the domain or range explicitly, + // since setting the domain or range (typically with a cardinality of more than + // two) is another indication that you intended for the scale to be ordinal; we + // also disable it for facet scales since these are always band scales. + if ( + options.type === undefined && + options.domain === undefined && + options.range === undefined && + options.interval == null && + key !== "fx" && + key !== "fy" && + isOrdinalScale({type}) + ) { + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isTemporal)) + warn( + `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isTemporalString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isNumericString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${formatScaleType( + type + )}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + } + + options.type = type; // Mutates input! + + // Once the scale type is known, coerce the associated channel values and any + // explicitly-specified domain to the expected type. + switch (type) { + case "diverging": + case "diverging-sqrt": + case "diverging-pow": + case "diverging-log": + case "diverging-symlog": + case "cyclical": + case "sequential": + case "linear": + case "sqrt": + case "threshold": + case "quantile": + case "pow": + case "log": + case "symlog": + options = coerceType(channels, options, coerceNumbers); + break; + case "identity": + switch (registry.get(key)) { + case position: + options = coerceType(channels, options, coerceNumbers); + break; + case symbol: + options = coerceType(channels, options, coerceSymbols); + break; + } + break; + case "utc": + case "time": + options = coerceType(channels, options, coerceDates); + break; + } + + switch (type) { + case "diverging": + return createScaleDiverging(key, channels, options); + case "diverging-sqrt": + return createScaleDivergingSqrt(key, channels, options); + case "diverging-pow": + return createScaleDivergingPow(key, channels, options); + case "diverging-log": + return createScaleDivergingLog(key, channels, options); + case "diverging-symlog": + return createScaleDivergingSymlog(key, channels, options); + case "categorical": + case "ordinal": + case ordinalImplicit: + return createScaleOrdinal(key, channels, options); + case "cyclical": + case "sequential": + case "linear": + return createScaleLinear(key, channels, options); + case "sqrt": + return createScaleSqrt(key, channels, options); + case "threshold": + return createScaleThreshold(key, channels, options); + case "quantile": + return createScaleQuantile(key, channels, options); + case "quantize": + return createScaleQuantize(key, channels, options); + case "pow": + return createScalePow(key, channels, options); + case "log": + return createScaleLog(key, channels, options); + case "symlog": + return createScaleSymlog(key, channels, options); + case "utc": + return createScaleUtc(key, channels, options); + case "time": + return createScaleTime(key, channels, options); + case "point": + return createScalePoint(key, channels, options); + case "band": + return createScaleBand(key, channels, options); + case "identity": + return registry.get(key) === position ? createScaleIdentity() : {type: "identity"}; + case undefined: + return; + default: + throw new Error(`unknown scale type: ${type}`); + } +} + +function formatScaleType(type) { + return typeof type === "symbol" ? type.description : type; +} + +// A special type symbol when the x and y scales are replaced with a projection. +const typeProjection = {toString: () => "projection"}; + +function inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) { + // The facet scales are always band scales; this cannot be changed. + if (key === "fx" || key === "fy") return "band"; + + // If a projection is specified, the x- and y-scales are disabled; these + // channels will be projected rather than scaled. (But still check that none + // of the associated channels are incompatible with a projection.) + if ((key === "x" || key === "y") && projection != null) type = typeProjection; + + // If a channel dictates a scale type, make sure that it is consistent with + // the user-specified scale type (if any) and all other channels. For example, + // barY requires x to be a band scale and disallows any other scale type. + for (const {type: t} of channels) { + if (t === undefined) continue; + else if (type === undefined) type = t; + else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`); + } + + // If the scale, a channel, or user specified a (consistent) type, return it. + if (type === typeProjection) return; + if (type !== undefined) return type; + + // If there’s no data (and no type) associated with this scale, don’t create a scale. + if (domain === undefined && !channels.some(({value}) => value !== undefined)) return; + + // Some scales have default types. + const kind = registry.get(key); + if (kind === radius) return "sqrt"; + if (kind === opacity || kind === length) return "linear"; + if (kind === symbol) return "ordinal"; + + // If the domain or range has more than two values, assume it’s ordinal. You + // can still use a “piecewise” (or “polylinear”) scale, but you must set the + // type explicitly. + if ((domain || range || []).length > 2) return asOrdinalType(kind); + + // Otherwise, infer the scale type from the data! Prefer the domain, if + // present, over channels. (The domain and channels should be consistently + // typed, and the domain is more explicit and typically much smaller.) We only + // check the first defined value for expedience and simplicity; we expect + // that the types are consistent. + if (domain !== undefined) { + if (isOrdinal(domain)) return asOrdinalType(kind); + if (isTemporal(domain)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; + } + + // If any channel is ordinal or temporal, it takes priority. + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isOrdinal)) return asOrdinalType(kind); + if (values.some(isTemporal)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; +} + +// Positional scales default to a point scale instead of an ordinal scale. +function asOrdinalType(kind) { + switch (kind) { + case position: + return "point"; + case color: + return ordinalImplicit; + default: + return "ordinal"; + } +} + +function isOrdinalScale({type}) { + return type === "ordinal" || type === "point" || type === "band" || type === ordinalImplicit; +} + +// Mutates channel.value! +function coerceType(channels, {domain, ...options}, coerceValues) { + for (const c of channels) { + if (c.value !== undefined) { + c.value = coerceValues(c.value); + } + } + return { + domain: domain === undefined ? domain : coerceValues(domain), + ...options + }; +} + +function coerceSymbols(values) { + return map(values, maybeSymbol); +} + +function scale(options = {}) { + let scale; + for (const key in options) { + if (!registry.has(key)) continue; // ignore unknown properties + if (!isScaleOptions(options[key])) continue; // e.g., ignore {color: "red"} + if (scale !== undefined) throw new Error("ambiguous scale definition; multiple scales found"); + scale = exposeScale(normalizeScale(key, options[key])); + } + if (scale === undefined) throw new Error("invalid scale definition; no scale found"); + return scale; +} + +// Note: axis- and legend-related properties (such as label, ticks and +// tickFormat) are not included here as they do not affect the scale’s behavior. +function exposeScale({scale, type, domain, range, interpolate, interval, transform, percent, pivot}) { + if (type === "identity") return {type: "identity", apply: (d) => d, invert: (d) => d}; + const unknown = scale.unknown ? scale.unknown() : undefined; + return { + type, + domain: slice(domain), // defensive copy + ...(range !== undefined && {range: slice(range)}), // defensive copy + ...(transform !== undefined && {transform}), + ...(percent && {percent}), // only exposed if truthy + ...(unknown !== undefined && {unknown}), + ...(interval !== undefined && {interval}), + + // quantitative + ...(interpolate !== undefined && {interpolate}), + ...(scale.clamp && {clamp: scale.clamp()}), + + // diverging (always asymmetric; we never want to apply the symmetric transform twice) + ...(pivot !== undefined && {pivot, symmetric: false}), + + // log, diverging-log + ...(scale.base && {base: scale.base()}), + + // pow, diverging-pow + ...(scale.exponent && {exponent: scale.exponent()}), + + // symlog, diverging-symlog + ...(scale.constant && {constant: scale.constant()}), + + // band, point + ...(scale.align && {align: scale.align(), round: scale.round()}), + ...(scale.padding && + (scale.paddingInner + ? {paddingInner: scale.paddingInner(), paddingOuter: scale.paddingOuter()} + : {padding: scale.padding()})), + ...(scale.bandwidth && {bandwidth: scale.bandwidth(), step: scale.step()}), + + // utilities + apply: (t) => scale(t), + ...(scale.invert && {invert: (t) => scale.invert(t)}) + }; +} + +function normalizedScale(scaleOptions) { + try { + var scaleType = Object.keys(scaleOptions)[0]; + return scale(_defineProperty({}, scaleType, Object.assign(Object.assign({}, scaleOptions[scaleType]), { + clamp: true + }))); + } catch (error) { + return null; + } +} +function scaleStyle(_scale, scaleOptions) { + var styles = {}; + if (scaleOptions.hasOwnProperty('opacity')) { + styles.fill = function () { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + scaleOptions.opacity.baseColor || SCALE_BASE_OPACITY_COLOR + ); + }; + styles['fill-opacity'] = function (d) { + return _scale === null || _scale === void 0 ? void 0 : _scale.apply(d); + }; + } else { + styles.fill = function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + typeof d === 'string' && (d === null || d === void 0 ? void 0 : d.startsWith('#')) ? d : _scale === null || _scale === void 0 ? void 0 : _scale.apply(d) + ); + }; + } + return styles; +} +function applyScaleStyle(elem, _scale, scaleOptions, keyname) { + Object.entries(scaleStyle(_scale, scaleOptions)).forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + prop = _ref2[0], + val = _ref2[1]; + return ( + // eslint-disable-next-line implicit-arrow-linebreak + elem.style(prop, function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + val(keyname ? d[keyname] : d) + ); + }) + ); + }); +} + +var Populator = /*#__PURE__*/function () { + function Populator(calendar) { + _classCallCheck(this, Populator); + this.calendar = calendar; + } + _createClass(Populator, [{ + key: "populate", + value: function populate() { + var calendar = this.calendar; + var _calendar$options$opt = calendar.options.options, + scale = _calendar$options$opt.scale, + subDomain = _calendar$options$opt.subDomain; + var colorScale = normalizedScale(scale); + calendar.calendarPainter.root.selectAll('.ch-domain').selectAll('svg').selectAll('g').data(function (d) { + return calendar.domainCollection.get(d) || []; + }).call(function (element) { + applyScaleStyle(element.select('rect'), colorScale, scale, 'v'); + }).call(function (element) { + element.select('text').attr('style', function (d) { + var defaultColor = hcl(colorScale === null || colorScale === void 0 ? void 0 : colorScale.apply(d.v)).l > 60 ? '#000' : '#fff'; + var color = subDomain.color || (d.v ? defaultColor : null); + if (isFunction(color)) { + color = color(d.t, d.v, colorScale === null || colorScale === void 0 ? void 0 : colorScale.apply(d.v)); + } + if (!color) { + return null; + } + return "fill: ".concat(color, ";"); + }).text(function (d, i, nodes) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + calendar.dateHelper.format(d.t, subDomain.label, d.v, nodes[i]) + ); + }); + }).call(function () { + calendar.eventEmitter.emit('fill'); + }); + } + }]); + return Populator; +}(); + +/** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ +function listCacheClear() { + this.__data__ = []; + this.size = 0; +} + +/** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ +function eq(value, other) { + return value === other || (value !== value && other !== other); +} + +/** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ +function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; +} + +/** Used for built-in method references. */ +var arrayProto = Array.prototype; + +/** Built-in value references. */ +var splice = arrayProto.splice; + +/** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; +} + +/** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; +} + +/** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; +} + +/** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ +function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; +} + +/** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function ListCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +// Add methods to `ListCache`. +ListCache.prototype.clear = listCacheClear; +ListCache.prototype['delete'] = listCacheDelete; +ListCache.prototype.get = listCacheGet; +ListCache.prototype.has = listCacheHas; +ListCache.prototype.set = listCacheSet; + +/** + * Removes all key-value entries from the stack. + * + * @private + * @name clear + * @memberOf Stack + */ +function stackClear() { + this.__data__ = new ListCache; + this.size = 0; +} + +/** + * Removes `key` and its value from the stack. + * + * @private + * @name delete + * @memberOf Stack + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function stackDelete(key) { + var data = this.__data__, + result = data['delete'](key); + + this.size = data.size; + return result; +} + +/** + * Gets the stack value for `key`. + * + * @private + * @name get + * @memberOf Stack + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function stackGet(key) { + return this.__data__.get(key); +} + +/** + * Checks if a stack value for `key` exists. + * + * @private + * @name has + * @memberOf Stack + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function stackHas(key) { + return this.__data__.has(key); +} + +/** Used to detect overreaching core-js shims. */ +var coreJsData = root$1['__core-js_shared__']; + +var coreJsData$1 = coreJsData; + +/** Used to detect methods masquerading as native. */ +var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData$1 && coreJsData$1.keys && coreJsData$1.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; +}()); + +/** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ +function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); +} + +/** Used for built-in method references. */ +var funcProto$2 = Function.prototype; + +/** Used to resolve the decompiled source of functions. */ +var funcToString$2 = funcProto$2.toString; + +/** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to convert. + * @returns {string} Returns the source code. + */ +function toSource(func) { + if (func != null) { + try { + return funcToString$2.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; +} + +/** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ +var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + +/** Used to detect host constructors (Safari). */ +var reIsHostCtor = /^\[object .+?Constructor\]$/; + +/** Used for built-in method references. */ +var funcProto$1 = Function.prototype, + objectProto$d = Object.prototype; + +/** Used to resolve the decompiled source of functions. */ +var funcToString$1 = funcProto$1.toString; + +/** Used to check objects for own properties. */ +var hasOwnProperty$b = objectProto$d.hasOwnProperty; + +/** Used to detect if a method is native. */ +var reIsNative = RegExp('^' + + funcToString$1.call(hasOwnProperty$b).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' +); + +/** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ +function baseIsNative(value) { + if (!isObject$2(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); +} + +/** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ +function getValue(object, key) { + return object == null ? undefined : object[key]; +} + +/** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ +function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; +} + +/* Built-in method references that are verified to be native. */ +var Map$1 = getNative(root$1, 'Map'); + +var Map$2 = Map$1; + +/* Built-in method references that are verified to be native. */ +var nativeCreate = getNative(Object, 'create'); + +var nativeCreate$1 = nativeCreate; + +/** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ +function hashClear() { + this.__data__ = nativeCreate$1 ? nativeCreate$1(null) : {}; + this.size = 0; +} + +/** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; +} + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED$2 = '__lodash_hash_undefined__'; + +/** Used for built-in method references. */ +var objectProto$c = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty$a = objectProto$c.hasOwnProperty; + +/** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function hashGet(key) { + var data = this.__data__; + if (nativeCreate$1) { + var result = data[key]; + return result === HASH_UNDEFINED$2 ? undefined : result; + } + return hasOwnProperty$a.call(data, key) ? data[key] : undefined; +} + +/** Used for built-in method references. */ +var objectProto$b = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty$9 = objectProto$b.hasOwnProperty; + +/** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function hashHas(key) { + var data = this.__data__; + return nativeCreate$1 ? (data[key] !== undefined) : hasOwnProperty$9.call(data, key); +} + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED$1 = '__lodash_hash_undefined__'; + +/** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ +function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = (nativeCreate$1 && value === undefined) ? HASH_UNDEFINED$1 : value; + return this; +} + +/** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Hash(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +// Add methods to `Hash`. +Hash.prototype.clear = hashClear; +Hash.prototype['delete'] = hashDelete; +Hash.prototype.get = hashGet; +Hash.prototype.has = hashHas; +Hash.prototype.set = hashSet; + +/** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ +function mapCacheClear() { + this.size = 0; + this.__data__ = { + 'hash': new Hash, + 'map': new (Map$2 || ListCache), + 'string': new Hash + }; +} + +/** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ +function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); +} + +/** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ +function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; +} + +/** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ +function mapCacheDelete(key) { + var result = getMapData(this, key)['delete'](key); + this.size -= result ? 1 : 0; + return result; +} + +/** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ +function mapCacheGet(key) { + return getMapData(this, key).get(key); +} + +/** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function mapCacheHas(key) { + return getMapData(this, key).has(key); +} + +/** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ +function mapCacheSet(key, value) { + var data = getMapData(this, key), + size = data.size; + + data.set(key, value); + this.size += data.size == size ? 0 : 1; + return this; +} + +/** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function MapCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } +} + +// Add methods to `MapCache`. +MapCache.prototype.clear = mapCacheClear; +MapCache.prototype['delete'] = mapCacheDelete; +MapCache.prototype.get = mapCacheGet; +MapCache.prototype.has = mapCacheHas; +MapCache.prototype.set = mapCacheSet; + +/** Used as the size to enable large array optimizations. */ +var LARGE_ARRAY_SIZE = 200; + +/** + * Sets the stack `key` to `value`. + * + * @private + * @name set + * @memberOf Stack + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the stack cache instance. + */ +function stackSet(key, value) { + var data = this.__data__; + if (data instanceof ListCache) { + var pairs = data.__data__; + if (!Map$2 || (pairs.length < LARGE_ARRAY_SIZE - 1)) { + pairs.push([key, value]); + this.size = ++data.size; + return this; + } + data = this.__data__ = new MapCache(pairs); + } + data.set(key, value); + this.size = data.size; + return this; +} + +/** + * Creates a stack cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ +function Stack(entries) { + var data = this.__data__ = new ListCache(entries); + this.size = data.size; +} + +// Add methods to `Stack`. +Stack.prototype.clear = stackClear; +Stack.prototype['delete'] = stackDelete; +Stack.prototype.get = stackGet; +Stack.prototype.has = stackHas; +Stack.prototype.set = stackSet; + +var defineProperty = (function() { + try { + var func = getNative(Object, 'defineProperty'); + func({}, '', {}); + return func; + } catch (e) {} +}()); + +var defineProperty$1 = defineProperty; + +/** + * The base implementation of `assignValue` and `assignMergeValue` without + * value checks. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ +function baseAssignValue(object, key, value) { + if (key == '__proto__' && defineProperty$1) { + defineProperty$1(object, key, { + 'configurable': true, + 'enumerable': true, + 'value': value, + 'writable': true + }); + } else { + object[key] = value; + } +} + +/** + * This function is like `assignValue` except that it doesn't assign + * `undefined` values. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ +function assignMergeValue(object, key, value) { + if ((value !== undefined && !eq(object[key], value)) || + (value === undefined && !(key in object))) { + baseAssignValue(object, key, value); + } +} + +/** + * Creates a base function for methods like `_.forIn` and `_.forOwn`. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ +function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var index = -1, + iterable = Object(object), + props = keysFunc(object), + length = props.length; + + while (length--) { + var key = props[fromRight ? length : ++index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; +} + +/** + * The base implementation of `baseForOwn` which iterates over `object` + * properties returned by `keysFunc` and invokes `iteratee` for each property. + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ +var baseFor = createBaseFor(); + +var baseFor$1 = baseFor; + +/** Detect free variable `exports`. */ +var freeExports$2 = typeof exports == 'object' && exports && !exports.nodeType && exports; + +/** Detect free variable `module`. */ +var freeModule$2 = freeExports$2 && typeof module == 'object' && module && !module.nodeType && module; + +/** Detect the popular CommonJS extension `module.exports`. */ +var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2; + +/** Built-in value references. */ +var Buffer$1 = moduleExports$2 ? root$1.Buffer : undefined, + allocUnsafe = Buffer$1 ? Buffer$1.allocUnsafe : undefined; + +/** + * Creates a clone of `buffer`. + * + * @private + * @param {Buffer} buffer The buffer to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Buffer} Returns the cloned buffer. + */ +function cloneBuffer(buffer, isDeep) { + if (isDeep) { + return buffer.slice(); + } + var length = buffer.length, + result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); + + buffer.copy(result); + return result; +} + +/** Built-in value references. */ +var Uint8Array$1 = root$1.Uint8Array; + +var Uint8Array$2 = Uint8Array$1; + +/** + * Creates a clone of `arrayBuffer`. + * + * @private + * @param {ArrayBuffer} arrayBuffer The array buffer to clone. + * @returns {ArrayBuffer} Returns the cloned array buffer. + */ +function cloneArrayBuffer(arrayBuffer) { + var result = new arrayBuffer.constructor(arrayBuffer.byteLength); + new Uint8Array$2(result).set(new Uint8Array$2(arrayBuffer)); + return result; +} + +/** + * Creates a clone of `typedArray`. + * + * @private + * @param {Object} typedArray The typed array to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned typed array. + */ +function cloneTypedArray(typedArray, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; + return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); +} + +/** + * Copies the values of `source` to `array`. + * + * @private + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. + */ +function copyArray(source, array) { + var index = -1, + length = source.length; + + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; +} + +/** Built-in value references. */ +var objectCreate = Object.create; + +/** + * The base implementation of `_.create` without support for assigning + * properties to the created object. + * + * @private + * @param {Object} proto The object to inherit from. + * @returns {Object} Returns the new object. + */ +var baseCreate = (function() { + function object() {} + return function(proto) { + if (!isObject$2(proto)) { + return {}; + } + if (objectCreate) { + return objectCreate(proto); + } + object.prototype = proto; + var result = new object; + object.prototype = undefined; + return result; + }; +}()); + +var baseCreate$1 = baseCreate; + +/** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ +function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; +} + +/** Built-in value references. */ +var getPrototype = overArg(Object.getPrototypeOf, Object); + +var getPrototype$1 = getPrototype; + +/** Used for built-in method references. */ +var objectProto$a = Object.prototype; + +/** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ +function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$a; + + return value === proto; +} + +/** + * Initializes an object clone. + * + * @private + * @param {Object} object The object to clone. + * @returns {Object} Returns the initialized clone. + */ +function initCloneObject(object) { + return (typeof object.constructor == 'function' && !isPrototype(object)) + ? baseCreate$1(getPrototype$1(object)) + : {}; +} + +/** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ +function isObjectLike(value) { + return value != null && typeof value == 'object'; +} + +/** `Object#toString` result references. */ +var argsTag$2 = '[object Arguments]'; + +/** + * The base implementation of `_.isArguments`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + */ +function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag$2; +} + +/** Used for built-in method references. */ +var objectProto$9 = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty$8 = objectProto$9.hasOwnProperty; + +/** Built-in value references. */ +var propertyIsEnumerable$1 = objectProto$9.propertyIsEnumerable; + +/** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ +var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty$8.call(value, 'callee') && + !propertyIsEnumerable$1.call(value, 'callee'); +}; + +var isArguments$1 = isArguments; + +/** Used as references for various `Number` constants. */ +var MAX_SAFE_INTEGER$1 = 9007199254740991; + +/** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ +function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$1; +} + +/** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ +function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); +} + +/** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ +function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); +} + +/** + * This method returns `false`. + * + * @static + * @memberOf _ + * @since 4.13.0 + * @category Util + * @returns {boolean} Returns `false`. + * @example + * + * _.times(2, _.stubFalse); + * // => [false, false] + */ +function stubFalse() { + return false; +} + +/** Detect free variable `exports`. */ +var freeExports$1 = typeof exports == 'object' && exports && !exports.nodeType && exports; + +/** Detect free variable `module`. */ +var freeModule$1 = freeExports$1 && typeof module == 'object' && module && !module.nodeType && module; + +/** Detect the popular CommonJS extension `module.exports`. */ +var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1; + +/** Built-in value references. */ +var Buffer = moduleExports$1 ? root$1.Buffer : undefined; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined; + +/** + * Checks if `value` is a buffer. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false + */ +var isBuffer = nativeIsBuffer || stubFalse; + +var isBuffer$1 = isBuffer; + +/** `Object#toString` result references. */ +var objectTag$3 = '[object Object]'; + +/** Used for built-in method references. */ +var funcProto = Function.prototype, + objectProto$8 = Object.prototype; + +/** Used to resolve the decompiled source of functions. */ +var funcToString = funcProto.toString; + +/** Used to check objects for own properties. */ +var hasOwnProperty$7 = objectProto$8.hasOwnProperty; + +/** Used to infer the `Object` constructor. */ +var objectCtorString = funcToString.call(Object); + +/** + * Checks if `value` is a plain object, that is, an object created by the + * `Object` constructor or one with a `[[Prototype]]` of `null`. + * + * @static + * @memberOf _ + * @since 0.8.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * _.isPlainObject(new Foo); + * // => false + * + * _.isPlainObject([1, 2, 3]); + * // => false + * + * _.isPlainObject({ 'x': 0, 'y': 0 }); + * // => true + * + * _.isPlainObject(Object.create(null)); + * // => true + */ +function isPlainObject(value) { + if (!isObjectLike(value) || baseGetTag(value) != objectTag$3) { + return false; + } + var proto = getPrototype$1(value); + if (proto === null) { + return true; + } + var Ctor = hasOwnProperty$7.call(proto, 'constructor') && proto.constructor; + return typeof Ctor == 'function' && Ctor instanceof Ctor && + funcToString.call(Ctor) == objectCtorString; +} + +/** `Object#toString` result references. */ +var argsTag$1 = '[object Arguments]', + arrayTag$1 = '[object Array]', + boolTag$1 = '[object Boolean]', + dateTag$1 = '[object Date]', + errorTag$1 = '[object Error]', + funcTag = '[object Function]', + mapTag$2 = '[object Map]', + numberTag$1 = '[object Number]', + objectTag$2 = '[object Object]', + regexpTag$1 = '[object RegExp]', + setTag$2 = '[object Set]', + stringTag$2 = '[object String]', + weakMapTag$1 = '[object WeakMap]'; + +var arrayBufferTag$1 = '[object ArrayBuffer]', + dataViewTag$2 = '[object DataView]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + +/** Used to identify `toStringTag` values of typed arrays. */ +var typedArrayTags = {}; +typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = +typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = +typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = +typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = +typedArrayTags[uint32Tag] = true; +typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = +typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$1] = +typedArrayTags[dataViewTag$2] = typedArrayTags[dateTag$1] = +typedArrayTags[errorTag$1] = typedArrayTags[funcTag] = +typedArrayTags[mapTag$2] = typedArrayTags[numberTag$1] = +typedArrayTags[objectTag$2] = typedArrayTags[regexpTag$1] = +typedArrayTags[setTag$2] = typedArrayTags[stringTag$2] = +typedArrayTags[weakMapTag$1] = false; + +/** + * The base implementation of `_.isTypedArray` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + */ +function baseIsTypedArray(value) { + return isObjectLike(value) && + isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; +} + +/** + * The base implementation of `_.unary` without support for storing metadata. + * + * @private + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + */ +function baseUnary(func) { + return function(value) { + return func(value); + }; +} + +/** Detect free variable `exports`. */ +var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; + +/** Detect free variable `module`. */ +var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; + +/** Detect the popular CommonJS extension `module.exports`. */ +var moduleExports = freeModule && freeModule.exports === freeExports; + +/** Detect free variable `process` from Node.js. */ +var freeProcess = moduleExports && freeGlobal$1.process; + +/** Used to access faster Node.js helpers. */ +var nodeUtil = (function() { + try { + // Use `util.types` for Node.js 10+. + var types = freeModule && freeModule.require && freeModule.require('util').types; + + if (types) { + return types; + } + + // Legacy `process.binding('util')` for Node.js < 10. + return freeProcess && freeProcess.binding && freeProcess.binding('util'); + } catch (e) {} +}()); + +var nodeUtil$1 = nodeUtil; + +/* Node.js helper references. */ +var nodeIsTypedArray = nodeUtil$1 && nodeUtil$1.isTypedArray; + +/** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */ +var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; + +var isTypedArray$1 = isTypedArray; + +/** + * Gets the value at `key`, unless `key` is "__proto__" or "constructor". + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ +function safeGet(object, key) { + if (key === 'constructor' && typeof object[key] === 'function') { + return; + } + + if (key == '__proto__') { + return; + } + + return object[key]; +} + +/** Used for built-in method references. */ +var objectProto$7 = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty$6 = objectProto$7.hasOwnProperty; + +/** + * Assigns `value` to `key` of `object` if the existing value is not equivalent + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ +function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty$6.call(object, key) && eq(objValue, value)) || + (value === undefined && !(key in object))) { + baseAssignValue(object, key, value); + } +} + +/** + * Copies properties of `source` to `object`. + * + * @private + * @param {Object} source The object to copy properties from. + * @param {Array} props The property identifiers to copy. + * @param {Object} [object={}] The object to copy properties to. + * @param {Function} [customizer] The function to customize copied values. + * @returns {Object} Returns `object`. + */ +function copyObject(source, props, object, customizer) { + var isNew = !object; + object || (object = {}); + + var index = -1, + length = props.length; + + while (++index < length) { + var key = props[index]; + + var newValue = customizer + ? customizer(object[key], source[key], key, object, source) + : undefined; + + if (newValue === undefined) { + newValue = source[key]; + } + if (isNew) { + baseAssignValue(object, key, newValue); + } else { + assignValue(object, key, newValue); + } + } + return object; +} + +/** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ +function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + return result; +} + +/** Used as references for various `Number` constants. */ +var MAX_SAFE_INTEGER = 9007199254740991; + +/** Used to detect unsigned integer values. */ +var reIsUint = /^(?:0|[1-9]\d*)$/; + +/** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ +function isIndex(value, length) { + var type = typeof value; + length = length == null ? MAX_SAFE_INTEGER : length; + + return !!length && + (type == 'number' || + (type != 'symbol' && reIsUint.test(value))) && + (value > -1 && value % 1 == 0 && value < length); +} + +/** Used for built-in method references. */ +var objectProto$6 = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty$5 = objectProto$6.hasOwnProperty; + +/** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ +function arrayLikeKeys(value, inherited) { + var isArr = isArray$3(value), + isArg = !isArr && isArguments$1(value), + isBuff = !isArr && !isArg && isBuffer$1(value), + isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), + skipIndexes = isArr || isArg || isBuff || isType, + result = skipIndexes ? baseTimes(value.length, String) : [], + length = result.length; + + for (var key in value) { + if ((inherited || hasOwnProperty$5.call(value, key)) && + !(skipIndexes && ( + // Safari 9 has enumerable `arguments.length` in strict mode. + key == 'length' || + // Node.js 0.10 has enumerable non-index properties on buffers. + (isBuff && (key == 'offset' || key == 'parent')) || + // PhantomJS 2 has enumerable non-index properties on typed arrays. + (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || + // Skip index properties. + isIndex(key, length) + ))) { + result.push(key); + } + } + return result; +} + +/** + * This function is like + * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * except that it includes inherited enumerable properties. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ +function nativeKeysIn(object) { + var result = []; + if (object != null) { + for (var key in Object(object)) { + result.push(key); + } + } + return result; +} + +/** Used for built-in method references. */ +var objectProto$5 = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty$4 = objectProto$5.hasOwnProperty; + +/** + * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ +function baseKeysIn(object) { + if (!isObject$2(object)) { + return nativeKeysIn(object); + } + var isProto = isPrototype(object), + result = []; + + for (var key in object) { + if (!(key == 'constructor' && (isProto || !hasOwnProperty$4.call(object, key)))) { + result.push(key); + } + } + return result; +} + +/** + * Creates an array of the own and inherited enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) + */ +function keysIn(object) { + return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); +} + +/** + * Converts `value` to a plain object flattening inherited enumerable string + * keyed properties of `value` to own properties of the plain object. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {Object} Returns the converted plain object. + * @example + * + * function Foo() { + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.assign({ 'a': 1 }, new Foo); + * // => { 'a': 1, 'b': 2 } + * + * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); + * // => { 'a': 1, 'b': 2, 'c': 3 } + */ +function toPlainObject(value) { + return copyObject(value, keysIn(value)); +} + +/** + * A specialized version of `baseMerge` for arrays and objects which performs + * deep merges and tracks traversed objects enabling objects with circular + * references to be merged. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {string} key The key of the value to merge. + * @param {number} srcIndex The index of `source`. + * @param {Function} mergeFunc The function to merge values. + * @param {Function} [customizer] The function to customize assigned values. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + */ +function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { + var objValue = safeGet(object, key), + srcValue = safeGet(source, key), + stacked = stack.get(srcValue); + + if (stacked) { + assignMergeValue(object, key, stacked); + return; + } + var newValue = customizer + ? customizer(objValue, srcValue, (key + ''), object, source, stack) + : undefined; + + var isCommon = newValue === undefined; + + if (isCommon) { + var isArr = isArray$3(srcValue), + isBuff = !isArr && isBuffer$1(srcValue), + isTyped = !isArr && !isBuff && isTypedArray$1(srcValue); + + newValue = srcValue; + if (isArr || isBuff || isTyped) { + if (isArray$3(objValue)) { + newValue = objValue; + } + else if (isArrayLikeObject(objValue)) { + newValue = copyArray(objValue); + } + else if (isBuff) { + isCommon = false; + newValue = cloneBuffer(srcValue, true); + } + else if (isTyped) { + isCommon = false; + newValue = cloneTypedArray(srcValue, true); + } + else { + newValue = []; + } + } + else if (isPlainObject(srcValue) || isArguments$1(srcValue)) { + newValue = objValue; + if (isArguments$1(objValue)) { + newValue = toPlainObject(objValue); + } + else if (!isObject$2(objValue) || isFunction(objValue)) { + newValue = initCloneObject(srcValue); + } + } + else { + isCommon = false; + } + } + if (isCommon) { + // Recursively merge objects and arrays (susceptible to call stack limits). + stack.set(srcValue, newValue); + mergeFunc(newValue, srcValue, srcIndex, customizer, stack); + stack['delete'](srcValue); + } + assignMergeValue(object, key, newValue); +} + +/** + * The base implementation of `_.merge` without support for multiple sources. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {number} srcIndex The index of `source`. + * @param {Function} [customizer] The function to customize merged values. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + */ +function baseMerge(object, source, srcIndex, customizer, stack) { + if (object === source) { + return; + } + baseFor$1(source, function(srcValue, key) { + stack || (stack = new Stack); + if (isObject$2(srcValue)) { + baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); + } + else { + var newValue = customizer + ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack) + : undefined; + + if (newValue === undefined) { + newValue = srcValue; + } + assignMergeValue(object, key, newValue); + } + }, keysIn); +} + +/** + * This method returns the first argument it receives. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Util + * @param {*} value Any value. + * @returns {*} Returns `value`. + * @example + * + * var object = { 'a': 1 }; + * + * console.log(_.identity(object) === object); + * // => true + */ +function identity(value) { + return value; +} + +/** + * A faster alternative to `Function#apply`, this function invokes `func` + * with the `this` binding of `thisArg` and the arguments of `args`. + * + * @private + * @param {Function} func The function to invoke. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} args The arguments to invoke `func` with. + * @returns {*} Returns the result of `func`. + */ +function apply$1(func, thisArg, args) { + switch (args.length) { + case 0: return func.call(thisArg); + case 1: return func.call(thisArg, args[0]); + case 2: return func.call(thisArg, args[0], args[1]); + case 3: return func.call(thisArg, args[0], args[1], args[2]); + } + return func.apply(thisArg, args); +} + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeMax = Math.max; + +/** + * A specialized version of `baseRest` which transforms the rest array. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @param {Function} transform The rest array transform. + * @returns {Function} Returns the new function. + */ +function overRest(func, start, transform) { + start = nativeMax(start === undefined ? (func.length - 1) : start, 0); + return function() { + var args = arguments, + index = -1, + length = nativeMax(args.length - start, 0), + array = Array(length); + + while (++index < length) { + array[index] = args[start + index]; + } + index = -1; + var otherArgs = Array(start + 1); + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = transform(array); + return apply$1(func, this, otherArgs); + }; +} + +/** + * Creates a function that returns `value`. + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Util + * @param {*} value The value to return from the new function. + * @returns {Function} Returns the new constant function. + * @example + * + * var objects = _.times(2, _.constant({ 'a': 1 })); + * + * console.log(objects); + * // => [{ 'a': 1 }, { 'a': 1 }] + * + * console.log(objects[0] === objects[1]); + * // => true + */ +function constant(value) { + return function() { + return value; + }; +} + +/** + * The base implementation of `setToString` without support for hot loop shorting. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ +var baseSetToString = !defineProperty$1 ? identity : function(func, string) { + return defineProperty$1(func, 'toString', { + 'configurable': true, + 'enumerable': false, + 'value': constant(string), + 'writable': true + }); +}; + +var baseSetToString$1 = baseSetToString; + +/** Used to detect hot functions by number of calls within a span of milliseconds. */ +var HOT_COUNT = 800, + HOT_SPAN = 16; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeNow = Date.now; + +/** + * Creates a function that'll short out and invoke `identity` instead + * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` + * milliseconds. + * + * @private + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new shortable function. + */ +function shortOut(func) { + var count = 0, + lastCalled = 0; + + return function() { + var stamp = nativeNow(), + remaining = HOT_SPAN - (stamp - lastCalled); + + lastCalled = stamp; + if (remaining > 0) { + if (++count >= HOT_COUNT) { + return arguments[0]; + } + } else { + count = 0; + } + return func.apply(undefined, arguments); + }; +} + +/** + * Sets the `toString` method of `func` to return `string`. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ +var setToString = shortOut(baseSetToString$1); + +var setToString$1 = setToString; + +/** + * The base implementation of `_.rest` which doesn't validate or coerce arguments. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + */ +function baseRest(func, start) { + return setToString$1(overRest(func, start, identity), func + ''); +} + +/** + * Checks if the given arguments are from an iteratee call. + * + * @private + * @param {*} value The potential iteratee value argument. + * @param {*} index The potential iteratee index or key argument. + * @param {*} object The potential iteratee object argument. + * @returns {boolean} Returns `true` if the arguments are from an iteratee call, + * else `false`. + */ +function isIterateeCall(value, index, object) { + if (!isObject$2(object)) { + return false; + } + var type = typeof index; + if (type == 'number' + ? (isArrayLike(object) && isIndex(index, object.length)) + : (type == 'string' && index in object) + ) { + return eq(object[index], value); + } + return false; +} + +/** + * Creates a function like `_.assign`. + * + * @private + * @param {Function} assigner The function to assign values. + * @returns {Function} Returns the new assigner function. + */ +function createAssigner(assigner) { + return baseRest(function(object, sources) { + var index = -1, + length = sources.length, + customizer = length > 1 ? sources[length - 1] : undefined, + guard = length > 2 ? sources[2] : undefined; + + customizer = (assigner.length > 3 && typeof customizer == 'function') + ? (length--, customizer) + : undefined; + + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + customizer = length < 3 ? undefined : customizer; + length = 1; + } + object = Object(object); + while (++index < length) { + var source = sources[index]; + if (source) { + assigner(object, source, index, customizer); + } + } + return object; + }); +} + +/** + * This method is like `_.merge` except that it accepts `customizer` which + * is invoked to produce the merged values of the destination and source + * properties. If `customizer` returns `undefined`, merging is handled by the + * method instead. The `customizer` is invoked with six arguments: + * (objValue, srcValue, key, object, source, stack). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} customizer The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * if (_.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * } + * + * var object = { 'a': [1], 'b': [2] }; + * var other = { 'a': [3], 'b': [4] }; + * + * _.mergeWith(object, other, customizer); + * // => { 'a': [1, 3], 'b': [2, 4] } + */ +var mergeWith = createAssigner(function(object, source, srcIndex, customizer) { + baseMerge(object, source, srcIndex, customizer); +}); + +var mergeWith$1 = mergeWith; + +/** Used to stand-in for `undefined` hash values. */ +var HASH_UNDEFINED = '__lodash_hash_undefined__'; + +/** + * Adds `value` to the array cache. + * + * @private + * @name add + * @memberOf SetCache + * @alias push + * @param {*} value The value to cache. + * @returns {Object} Returns the cache instance. + */ +function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; +} + +/** + * Checks if `value` is in the array cache. + * + * @private + * @name has + * @memberOf SetCache + * @param {*} value The value to search for. + * @returns {number} Returns `true` if `value` is found, else `false`. + */ +function setCacheHas(value) { + return this.__data__.has(value); +} + +/** + * + * Creates an array cache object to store unique values. + * + * @private + * @constructor + * @param {Array} [values] The values to cache. + */ +function SetCache(values) { + var index = -1, + length = values == null ? 0 : values.length; + + this.__data__ = new MapCache; + while (++index < length) { + this.add(values[index]); + } +} + +// Add methods to `SetCache`. +SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; +SetCache.prototype.has = setCacheHas; + +/** + * A specialized version of `_.some` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ +function arraySome(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; +} + +/** + * Checks if a `cache` value for `key` exists. + * + * @private + * @param {Object} cache The cache to query. + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ +function cacheHas(cache, key) { + return cache.has(key); +} + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG$3 = 1, + COMPARE_UNORDERED_FLAG$1 = 2; + +/** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `array` and `other` objects. + * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. + */ +function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, + arrLength = array.length, + othLength = other.length; + + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + // Check that cyclic values are equal. + var arrStacked = stack.get(array); + var othStacked = stack.get(other); + if (arrStacked && othStacked) { + return arrStacked == other && othStacked == array; + } + var index = -1, + result = true, + seen = (bitmask & COMPARE_UNORDERED_FLAG$1) ? new SetCache : undefined; + + stack.set(array, other); + stack.set(other, array); + + // Ignore non-index properties. + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, arrValue, index, other, array, stack) + : customizer(arrValue, othValue, index, array, other, stack); + } + if (compared !== undefined) { + if (compared) { + continue; + } + result = false; + break; + } + // Recursively compare arrays (susceptible to call stack limits). + if (seen) { + if (!arraySome(other, function(othValue, othIndex) { + if (!cacheHas(seen, othIndex) && + (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + return seen.push(othIndex); + } + })) { + result = false; + break; + } + } else if (!( + arrValue === othValue || + equalFunc(arrValue, othValue, bitmask, customizer, stack) + )) { + result = false; + break; + } + } + stack['delete'](array); + stack['delete'](other); + return result; +} + +/** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */ +function mapToArray(map) { + var index = -1, + result = Array(map.size); + + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; +} + +/** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ +function setToArray(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = value; + }); + return result; +} + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG$2 = 1, + COMPARE_UNORDERED_FLAG = 2; + +/** `Object#toString` result references. */ +var boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + mapTag$1 = '[object Map]', + numberTag = '[object Number]', + regexpTag = '[object RegExp]', + setTag$1 = '[object Set]', + stringTag$1 = '[object String]', + symbolTag$1 = '[object Symbol]'; + +var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag$1 = '[object DataView]'; + +/** Used to convert symbols to primitives and strings. */ +var symbolProto$1 = Symbol$2 ? Symbol$2.prototype : undefined, + symbolValueOf = symbolProto$1 ? symbolProto$1.valueOf : undefined; + +/** + * A specialized version of `baseIsEqualDeep` for comparing objects of + * the same `toStringTag`. + * + * **Note:** This function only supports comparing values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {string} tag The `toStringTag` of the objects to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ +function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { + switch (tag) { + case dataViewTag$1: + if ((object.byteLength != other.byteLength) || + (object.byteOffset != other.byteOffset)) { + return false; + } + object = object.buffer; + other = other.buffer; + + case arrayBufferTag: + if ((object.byteLength != other.byteLength) || + !equalFunc(new Uint8Array$2(object), new Uint8Array$2(other))) { + return false; + } + return true; + + case boolTag: + case dateTag: + case numberTag: + // Coerce booleans to `1` or `0` and dates to milliseconds. + // Invalid dates are coerced to `NaN`. + return eq(+object, +other); + + case errorTag: + return object.name == other.name && object.message == other.message; + + case regexpTag: + case stringTag$1: + // Coerce regexes to strings and treat strings, primitives and objects, + // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring + // for more details. + return object == (other + ''); + + case mapTag$1: + var convert = mapToArray; + + case setTag$1: + var isPartial = bitmask & COMPARE_PARTIAL_FLAG$2; + convert || (convert = setToArray); + + if (object.size != other.size && !isPartial) { + return false; + } + // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked) { + return stacked == other; + } + bitmask |= COMPARE_UNORDERED_FLAG; + + // Recursively compare objects (susceptible to call stack limits). + stack.set(object, other); + var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); + stack['delete'](object); + return result; + + case symbolTag$1: + if (symbolValueOf) { + return symbolValueOf.call(object) == symbolValueOf.call(other); + } + } + return false; +} + +/** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ +function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + return array; +} + +/** + * The base implementation of `getAllKeys` and `getAllKeysIn` which uses + * `keysFunc` and `symbolsFunc` to get the enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Function} keysFunc The function to get the keys of `object`. + * @param {Function} symbolsFunc The function to get the symbols of `object`. + * @returns {Array} Returns the array of property names and symbols. + */ +function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result = keysFunc(object); + return isArray$3(object) ? result : arrayPush(result, symbolsFunc(object)); +} + +/** + * A specialized version of `_.filter` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ +function arrayFilter(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result[resIndex++] = value; + } + } + return result; +} + +/** + * This method returns a new empty array. + * + * @static + * @memberOf _ + * @since 4.13.0 + * @category Util + * @returns {Array} Returns the new empty array. + * @example + * + * var arrays = _.times(2, _.stubArray); + * + * console.log(arrays); + * // => [[], []] + * + * console.log(arrays[0] === arrays[1]); + * // => false + */ +function stubArray() { + return []; +} + +/** Used for built-in method references. */ +var objectProto$4 = Object.prototype; + +/** Built-in value references. */ +var propertyIsEnumerable = objectProto$4.propertyIsEnumerable; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeGetSymbols = Object.getOwnPropertySymbols; + +/** + * Creates an array of the own enumerable symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ +var getSymbols = !nativeGetSymbols ? stubArray : function(object) { + if (object == null) { + return []; + } + object = Object(object); + return arrayFilter(nativeGetSymbols(object), function(symbol) { + return propertyIsEnumerable.call(object, symbol); + }); +}; + +var getSymbols$1 = getSymbols; + +/* Built-in method references for those with the same name as other `lodash` methods. */ +var nativeKeys = overArg(Object.keys, Object); + +var nativeKeys$1 = nativeKeys; + +/** Used for built-in method references. */ +var objectProto$3 = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty$3 = objectProto$3.hasOwnProperty; + +/** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ +function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys$1(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty$3.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; +} + +/** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ +function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); +} + +/** + * Creates an array of own enumerable property names and symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ +function getAllKeys(object) { + return baseGetAllKeys(object, keys, getSymbols$1); +} + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG$1 = 1; + +/** Used for built-in method references. */ +var objectProto$2 = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty$2 = objectProto$2.hasOwnProperty; + +/** + * A specialized version of `baseIsEqualDeep` for objects with support for + * partial deep comparisons. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ +function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG$1, + objProps = getAllKeys(object), + objLength = objProps.length, + othProps = getAllKeys(other), + othLength = othProps.length; + + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isPartial ? key in other : hasOwnProperty$2.call(other, key))) { + return false; + } + } + // Check that cyclic values are equal. + var objStacked = stack.get(object); + var othStacked = stack.get(other); + if (objStacked && othStacked) { + return objStacked == other && othStacked == object; + } + var result = true; + stack.set(object, other); + stack.set(other, object); + + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], + othValue = other[key]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, objValue, key, other, object, stack) + : customizer(objValue, othValue, key, object, other, stack); + } + // Recursively compare objects (susceptible to call stack limits). + if (!(compared === undefined + ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) + : compared + )) { + result = false; + break; + } + skipCtor || (skipCtor = key == 'constructor'); + } + if (result && !skipCtor) { + var objCtor = object.constructor, + othCtor = other.constructor; + + // Non `Object` object instances with different constructors are not equal. + if (objCtor != othCtor && + ('constructor' in object && 'constructor' in other) && + !(typeof objCtor == 'function' && objCtor instanceof objCtor && + typeof othCtor == 'function' && othCtor instanceof othCtor)) { + result = false; + } + } + stack['delete'](object); + stack['delete'](other); + return result; +} + +/* Built-in method references that are verified to be native. */ +var DataView = getNative(root$1, 'DataView'); + +var DataView$1 = DataView; + +/* Built-in method references that are verified to be native. */ +var Promise$1 = getNative(root$1, 'Promise'); + +var Promise$2 = Promise$1; + +/* Built-in method references that are verified to be native. */ +var Set$1 = getNative(root$1, 'Set'); + +var Set$2 = Set$1; + +/* Built-in method references that are verified to be native. */ +var WeakMap = getNative(root$1, 'WeakMap'); + +var WeakMap$1 = WeakMap; + +/** `Object#toString` result references. */ +var mapTag = '[object Map]', + objectTag$1 = '[object Object]', + promiseTag = '[object Promise]', + setTag = '[object Set]', + weakMapTag = '[object WeakMap]'; + +var dataViewTag = '[object DataView]'; + +/** Used to detect maps, sets, and weakmaps. */ +var dataViewCtorString = toSource(DataView$1), + mapCtorString = toSource(Map$2), + promiseCtorString = toSource(Promise$2), + setCtorString = toSource(Set$2), + weakMapCtorString = toSource(WeakMap$1); + +/** + * Gets the `toStringTag` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ +var getTag = baseGetTag; + +// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. +if ((DataView$1 && getTag(new DataView$1(new ArrayBuffer(1))) != dataViewTag) || + (Map$2 && getTag(new Map$2) != mapTag) || + (Promise$2 && getTag(Promise$2.resolve()) != promiseTag) || + (Set$2 && getTag(new Set$2) != setTag) || + (WeakMap$1 && getTag(new WeakMap$1) != weakMapTag)) { + getTag = function(value) { + var result = baseGetTag(value), + Ctor = result == objectTag$1 ? value.constructor : undefined, + ctorString = Ctor ? toSource(Ctor) : ''; + + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: return dataViewTag; + case mapCtorString: return mapTag; + case promiseCtorString: return promiseTag; + case setCtorString: return setTag; + case weakMapCtorString: return weakMapTag; + } + } + return result; + }; +} + +var getTag$1 = getTag; + +/** Used to compose bitmasks for value comparisons. */ +var COMPARE_PARTIAL_FLAG = 1; + +/** `Object#toString` result references. */ +var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + objectTag = '[object Object]'; + +/** Used for built-in method references. */ +var objectProto$1 = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty$1 = objectProto$1.hasOwnProperty; + +/** + * A specialized version of `baseIsEqual` for arrays and objects which performs + * deep comparisons and tracks traversed objects enabling objects with circular + * references to be compared. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} [stack] Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ +function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { + var objIsArr = isArray$3(object), + othIsArr = isArray$3(other), + objTag = objIsArr ? arrayTag : getTag$1(object), + othTag = othIsArr ? arrayTag : getTag$1(other); + + objTag = objTag == argsTag ? objectTag : objTag; + othTag = othTag == argsTag ? objectTag : othTag; + + var objIsObj = objTag == objectTag, + othIsObj = othTag == objectTag, + isSameTag = objTag == othTag; + + if (isSameTag && isBuffer$1(object)) { + if (!isBuffer$1(other)) { + return false; + } + objIsArr = true; + objIsObj = false; + } + if (isSameTag && !objIsObj) { + stack || (stack = new Stack); + return (objIsArr || isTypedArray$1(object)) + ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) + : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); + } + if (!(bitmask & COMPARE_PARTIAL_FLAG)) { + var objIsWrapped = objIsObj && hasOwnProperty$1.call(object, '__wrapped__'), + othIsWrapped = othIsObj && hasOwnProperty$1.call(other, '__wrapped__'); + + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object.value() : object, + othUnwrapped = othIsWrapped ? other.value() : other; + + stack || (stack = new Stack); + return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack); + return equalObjects(object, other, bitmask, customizer, equalFunc, stack); +} + +/** + * The base implementation of `_.isEqual` which supports partial comparisons + * and tracks traversed objects. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {boolean} bitmask The bitmask flags. + * 1 - Unordered comparison + * 2 - Partial comparison + * @param {Function} [customizer] The function to customize comparisons. + * @param {Object} [stack] Tracks traversed `value` and `other` objects. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + */ +function baseIsEqual(value, other, bitmask, customizer, stack) { + if (value === other) { + return true; + } + if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); +} + +/** + * Performs a deep comparison between two values to determine if they are + * equivalent. + * + * **Note:** This method supports comparing arrays, array buffers, booleans, + * date objects, error objects, maps, numbers, `Object` objects, regexes, + * sets, strings, symbols, and typed arrays. `Object` objects are compared + * by their own, not inherited, enumerable properties. Functions and DOM + * nodes are compared by strict equality, i.e. `===`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false + */ +function isEqual(value, other) { + return baseIsEqual(value, other); +} + +/** Used for built-in method references. */ +var objectProto = Object.prototype; + +/** Used to check objects for own properties. */ +var hasOwnProperty = objectProto.hasOwnProperty; + +/** + * The base implementation of `_.has` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ +function baseHas(object, key) { + return object != null && hasOwnProperty.call(object, key); +} + +/** `Object#toString` result references. */ +var symbolTag = '[object Symbol]'; + +/** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ +function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && baseGetTag(value) == symbolTag); +} + +/** Used to match property names within property paths. */ +var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/; + +/** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ +function isKey(value, object) { + if (isArray$3(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); +} + +/** Error message constants. */ +var FUNC_ERROR_TEXT = 'Expected a function'; + +/** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `clear`, `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */ +function memoize(func, resolver) { + if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; + + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; +} + +// Expose `MapCache`. +memoize.Cache = MapCache; + +/** Used as the maximum memoize cache size. */ +var MAX_MEMOIZE_SIZE = 500; + +/** + * A specialized version of `_.memoize` which clears the memoized function's + * cache when it exceeds `MAX_MEMOIZE_SIZE`. + * + * @private + * @param {Function} func The function to have its output memoized. + * @returns {Function} Returns the new memoized function. + */ +function memoizeCapped(func) { + var result = memoize(func, function(key) { + if (cache.size === MAX_MEMOIZE_SIZE) { + cache.clear(); + } + return key; + }); + + var cache = result.cache; + return result; +} + +/** Used to match property names within property paths. */ +var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + +/** Used to match backslashes in property paths. */ +var reEscapeChar = /\\(\\)?/g; + +/** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ +var stringToPath = memoizeCapped(function(string) { + var result = []; + if (string.charCodeAt(0) === 46 /* . */) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, subString) { + result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; +}); + +var stringToPath$1 = stringToPath; + +/** + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ +function arrayMap(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length, + result = Array(length); + + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; +} + +/** Used as references for various `Number` constants. */ +var INFINITY$1 = 1 / 0; + +/** Used to convert symbols to primitives and strings. */ +var symbolProto = Symbol$2 ? Symbol$2.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + +/** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ +function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isArray$3(value)) { + // Recursively convert values (susceptible to call stack limits). + return arrayMap(value, baseToString) + ''; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY$1) ? '-0' : result; +} + +/** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ +function toString$3(value) { + return value == null ? '' : baseToString(value); +} + +/** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @param {Object} [object] The object to query keys on. + * @returns {Array} Returns the cast property path array. + */ +function castPath(value, object) { + if (isArray$3(value)) { + return value; + } + return isKey(value, object) ? [value] : stringToPath$1(toString$3(value)); +} + +/** Used as references for various `Number` constants. */ +var INFINITY = 1 / 0; + +/** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ +function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; +} + +/** + * Checks if `path` exists on `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @param {Function} hasFunc The function to check properties. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + */ +function hasPath(object, path, hasFunc) { + path = castPath(path, object); + + var index = -1, + length = path.length, + result = false; + + while (++index < length) { + var key = toKey(path[index]); + if (!(result = object != null && hasFunc(object, key))) { + break; + } + object = object[key]; + } + if (result || ++index != length) { + return result; + } + length = object == null ? 0 : object.length; + return !!length && isLength(length) && isIndex(key, length) && + (isArray$3(object) || isArguments$1(object)); +} + +/** + * Checks if `path` is a direct property of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = { 'a': { 'b': 2 } }; + * var other = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.has(object, 'a'); + * // => true + * + * _.has(object, 'a.b'); + * // => true + * + * _.has(object, ['a', 'b']); + * // => true + * + * _.has(other, 'a'); + * // => false + */ +function has(object, path) { + return object != null && hasPath(object, path, baseHas); +} + +/** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ +function baseGet(object, path) { + path = castPath(path, object); + + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return (index && index == length) ? object : undefined; +} + +/** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */ +function get(object, path, defaultValue) { + var result = object == null ? undefined : baseGet(object, path); + return result === undefined ? defaultValue : result; +} + +/** + * The base implementation of `_.set`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ +function baseSet(object, path, value, customizer) { + if (!isObject$2(object)) { + return object; + } + path = castPath(path, object); + + var index = -1, + length = path.length, + lastIndex = length - 1, + nested = object; + + while (nested != null && ++index < length) { + var key = toKey(path[index]), + newValue = value; + + if (key === '__proto__' || key === 'constructor' || key === 'prototype') { + return object; + } + + if (index != lastIndex) { + var objValue = nested[key]; + newValue = customizer ? customizer(objValue, key, nested) : undefined; + if (newValue === undefined) { + newValue = isObject$2(objValue) + ? objValue + : (isIndex(path[index + 1]) ? [] : {}); + } + } + assignValue(nested, key, newValue); + nested = nested[key]; + } + return object; +} + +/** + * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, + * it's created. Arrays are created for missing index properties while objects + * are created for all other missing properties. Use `_.setWith` to customize + * `path` creation. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.set(object, 'a[0].b.c', 4); + * console.log(object.a[0].b.c); + * // => 4 + * + * _.set(object, ['x', '0', 'y', 'z'], 5); + * console.log(object.x[0].y.z); + * // => 5 + */ +function set(object, path, value) { + return object == null ? object : baseSet(object, path, value); +} + +/** `Object#toString` result references. */ +var stringTag = '[object String]'; + +/** + * Checks if `value` is classified as a `String` primitive or object. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a string, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false + */ +function isString(value) { + return typeof value == 'string' || + (!isArray$3(value) && isObjectLike(value) && baseGetTag(value) == stringTag); +} + +var OptionsPreProcessors = { + range: function range(value) { + return Math.max(+value, 1); + }, + 'date.highlight': function dateHighlight(args) { + return castArray(args); + }, + 'subDomain.label': function subDomainLabel(value) { + return ( + // eslint-disable-next-line + isString(value) && value !== '' || isFunction(value) ? value : null + ); + } +}; + +var Options = /*#__PURE__*/function () { + function Options() { + var processors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : OptionsPreProcessors; + _classCallCheck(this, Options); + this.preProcessors = processors; + this.options = { + // selector string of the container to append the graph to + // Accept any string value accepted by document.querySelector or CSS3 + // or an Element object + itemSelector: OPTIONS_DEFAULT_ITEM_SELECTOR, + // Number of domain to display on the graph + range: OPTIONS_DEFAULT_RANGE, + domain: { + type: OPTIONS_DEFAULT_DOMAIN_TYPE, + // Space between each domain, in pixel + gutter: 4, + padding: [0, 0, 0, 0], + // Whether to enable dynamic domain size + // The width/height on a domain depends on the number of + // subDomains items count + dynamicDimension: true, + // Whether to show most recent date first + sort: 'asc', + label: { + // Formatting of the domain label + // @default: undefined, will use the formatting + // according to domain type + // Accept any string accepted by dayjs.format() + // or a function + // + // Refer to https://day.js.org/docs/en/display/format + // for list of accepted string tokens used by dayjs.format() + text: undefined, + // valid: top, right, bottom, left + position: 'bottom', + // Valid are the direct svg values: start, middle, end + textAlign: 'middle', + // By default, there is no margin/padding around the label + offset: { + x: 0, + y: 0 + }, + rotate: null, + // Used only on vertical orientation + width: 100, + // Used only on horizontal orientation + height: 25 + } + }, + subDomain: { + type: OPTIONS_DEFAULT_SUBDOMAIN_TYPE, + // Width of each subDomain cell, in pixel + width: OPTIONS_DEFAULT_SUBDOMAIN_WIDTH, + // Height of each subDomain cell, in pixel + height: OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT, + // Space between each subDomain cell, in pixel + gutter: OPTIONS_DEFAULT_SUBDOMAIN_GUTTER, + // Radius of each subDomain cell, in pixel + radius: OPTIONS_DEFAULT_SUBDOMAIN_RADIUS, + // Formatting of the text inside each subDomain cell + // @default: null, no text + // Accept any string accepted by dayjs.format() + // or a function + // + // Refer to https://day.js.org/docs/en/display/format + // for list of accepted string tokens used by dayjs.format() + label: null, + color: undefined, + sort: 'asc' + }, + date: { + // Start date of the graph + // @default now + start: new Date(), + min: undefined, + max: undefined, + // List of dates to highlight + // Valid values: + // - []: don't highlight anything + // - an array of Date objects: highlight the specified dates + highlight: [], + locale: OPTIONS_DEFAULT_LOCALE, + timezone: undefined + }, + // Calendar orientation + // false: display domains side by side + // true : display domains one under the other + verticalOrientation: false, + data: { + // Data source + // URL, where to fetch the original datas + source: '', + // Data type + // Default: json + type: 'json', + requestInit: {}, + // keyname of the time property + x: '', + // keyname of the value property + y: '', + // Grouping function of the values + groupY: 'sum', + defaultValue: null + }, + scale: undefined, + // Animation duration, in ms + animationDuration: OPTIONS_DEFAULT_ANIMATION_DURATION, + // Theme mode: dark/light + theme: OPTIONS_DEFAULT_THEME, + // Internally used options, do not edit not set + x: { + domainHorizontalLabelWidth: 0, + domainVerticalLabelHeight: 0 + } + }; + } + /** + * Set a new value for an option, only if unchanged + * @param {string} key Name of the option + * @param {any} value Value of the option + * @return {boolean} Whether the option have been changed + */ + _createClass(Options, [{ + key: "set", + value: function set$1(key, value) { + if (!has(this.options, key) || isEqual(get(this.options, key), value)) { + return false; + } + set(this.options, key, has(this.preProcessors, key) ? get(this.preProcessors, key)(value) : value); + return true; + } + }, { + key: "init", + value: function init(opts) { + var _this = this; + this.options = Object.assign({}, mergeWith$1(this.options, opts, function (_, srcValue) { + return Array.isArray(srcValue) ? srcValue : undefined; + })); + var options = this.options; + Object.keys(this.preProcessors).forEach(function (key) { + set(options, key, get(_this.preProcessors, key)(get(options, key))); + }); + if (typeof options.scale === 'undefined') { + this.initScale(); + } + options.x.domainVerticalLabelHeight = options.domain.label.height; + // When the label is affecting the height + if (options.domain.label.position === 'top' || options.domain.label.position === 'bottom') { + options.x.domainHorizontalLabelWidth = 0; + } else { + options.x.domainVerticalLabelHeight = 0; + options.x.domainHorizontalLabelWidth = options.domain.label.width; + } + if (options.domain.label.text === null || options.domain.label.text === '') { + options.x.domainVerticalLabelHeight = 0; + options.x.domainHorizontalLabelWidth = 0; + } + } + }, { + key: "initScale", + value: function initScale() { + this.options.scale = { + color: { + scheme: SCALE_BASE_COLOR_SCHEME, + type: SCALE_BASE_COLOR_TYPE, + domain: SCALE_BASE_COLOR_DOMAIN + } + }; + } + }]); + return Options; +}(); + +var anObject$2 = anObject$f; + +// `RegExp.prototype.flags` getter implementation +// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags +var regexpFlags$1 = function () { + var that = anObject$2(this); + var result = ''; + if (that.hasIndices) result += 'd'; + if (that.global) result += 'g'; + if (that.ignoreCase) result += 'i'; + if (that.multiline) result += 'm'; + if (that.dotAll) result += 's'; + if (that.unicode) result += 'u'; + if (that.unicodeSets) result += 'v'; + if (that.sticky) result += 'y'; + return result; +}; + +var fails$4 = fails$u; +var global$3 = global$n; + +// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError +var $RegExp$2 = global$3.RegExp; + +var UNSUPPORTED_Y$1 = fails$4(function () { + var re = $RegExp$2('a', 'y'); + re.lastIndex = 2; + return re.exec('abcd') !== null; +}); + +// UC Browser bug +// https://github.com/zloirock/core-js/issues/1008 +var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$4(function () { + return !$RegExp$2('a', 'y').sticky; +}); + +var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$4(function () { + // https://bugzilla.mozilla.org/show_bug.cgi?id=773687 + var re = $RegExp$2('^r', 'gy'); + re.lastIndex = 2; + return re.exec('str') !== null; +}); + +var regexpStickyHelpers = { + BROKEN_CARET: BROKEN_CARET, + MISSED_STICKY: MISSED_STICKY, + UNSUPPORTED_Y: UNSUPPORTED_Y$1 +}; + +var fails$3 = fails$u; +var global$2 = global$n; + +// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError +var $RegExp$1 = global$2.RegExp; + +var regexpUnsupportedDotAll = fails$3(function () { + var re = $RegExp$1('.', 's'); + return !(re.dotAll && re.test('\n') && re.flags === 's'); +}); + +var fails$2 = fails$u; +var global$1 = global$n; + +// babel-minify and Closure Compiler transpiles RegExp('(?b)', 'g') -> /(?b)/g and it causes SyntaxError +var $RegExp = global$1.RegExp; + +var regexpUnsupportedNcg = fails$2(function () { + var re = $RegExp('(?b)', 'g'); + return re.exec('b').groups.a !== 'b' || + 'b'.replace(re, '$c') !== 'bc'; +}); + +/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */ +/* eslint-disable regexp/no-useless-quantifier -- testing */ +var call$2 = functionCall; +var uncurryThis$5 = functionUncurryThis; +var toString$2 = toString$9; +var regexpFlags = regexpFlags$1; +var stickyHelpers = regexpStickyHelpers; +var shared = sharedExports; +var create = objectCreate$1; +var getInternalState = internalState.get; +var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll; +var UNSUPPORTED_NCG = regexpUnsupportedNcg; + +var nativeReplace = shared('native-string-replace', String.prototype.replace); +var nativeExec = RegExp.prototype.exec; +var patchedExec = nativeExec; +var charAt$2 = uncurryThis$5(''.charAt); +var indexOf = uncurryThis$5(''.indexOf); +var replace$1 = uncurryThis$5(''.replace); +var stringSlice$2 = uncurryThis$5(''.slice); + +var UPDATES_LAST_INDEX_WRONG = (function () { + var re1 = /a/; + var re2 = /b*/g; + call$2(nativeExec, re1, 'a'); + call$2(nativeExec, re2, 'a'); + return re1.lastIndex !== 0 || re2.lastIndex !== 0; +})(); + +var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET; + +// nonparticipating capturing group, copied from es5-shim's String#split patch. +var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; + +var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG; + +if (PATCH) { + patchedExec = function exec(string) { + var re = this; + var state = getInternalState(re); + var str = toString$2(string); + var raw = state.raw; + var result, reCopy, lastIndex, match, i, object, group; + + if (raw) { + raw.lastIndex = re.lastIndex; + result = call$2(patchedExec, raw, str); + re.lastIndex = raw.lastIndex; + return result; + } + + var groups = state.groups; + var sticky = UNSUPPORTED_Y && re.sticky; + var flags = call$2(regexpFlags, re); + var source = re.source; + var charsAdded = 0; + var strCopy = str; + + if (sticky) { + flags = replace$1(flags, 'y', ''); + if (indexOf(flags, 'g') === -1) { + flags += 'g'; + } + + strCopy = stringSlice$2(str, re.lastIndex); + // Support anchored sticky behavior. + if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$2(str, re.lastIndex - 1) !== '\n')) { + source = '(?: ' + source + ')'; + strCopy = ' ' + strCopy; + charsAdded++; + } + // ^(? + rx + ) is needed, in combination with some str slicing, to + // simulate the 'y' flag. + reCopy = new RegExp('^(?:' + source + ')', flags); + } + + if (NPCG_INCLUDED) { + reCopy = new RegExp('^' + source + '$(?!\\s)', flags); + } + if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex; + + match = call$2(nativeExec, sticky ? reCopy : re, strCopy); + + if (sticky) { + if (match) { + match.input = stringSlice$2(match.input, charsAdded); + match[0] = stringSlice$2(match[0], charsAdded); + match.index = re.lastIndex; + re.lastIndex += match[0].length; + } else re.lastIndex = 0; + } else if (UPDATES_LAST_INDEX_WRONG && match) { + re.lastIndex = re.global ? match.index + match[0].length : lastIndex; + } + if (NPCG_INCLUDED && match && match.length > 1) { + // Fix browsers whose `exec` methods don't consistently return `undefined` + // for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/ + call$2(nativeReplace, match[0], reCopy, function () { + for (i = 1; i < arguments.length - 2; i++) { + if (arguments[i] === undefined) match[i] = undefined; + } + }); + } + + if (match && groups) { + match.groups = object = create(null); + for (i = 0; i < groups.length; i++) { + group = groups[i]; + object[group[0]] = match[group[1]]; + } + } + + return match; + }; +} + +var regexpExec$2 = patchedExec; + +var $$1 = _export; +var exec = regexpExec$2; + +// `RegExp.prototype.exec` method +// https://tc39.es/ecma262/#sec-regexp.prototype.exec +$$1({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, { + exec: exec +}); + +// TODO: Remove from `core-js@4` since it's moved to entry points + +var uncurryThis$4 = functionUncurryThisClause; +var defineBuiltIn = defineBuiltIn$9; +var regexpExec$1 = regexpExec$2; +var fails$1 = fails$u; +var wellKnownSymbol$1 = wellKnownSymbol$m; +var createNonEnumerableProperty = createNonEnumerableProperty$6; + +var SPECIES = wellKnownSymbol$1('species'); +var RegExpPrototype = RegExp.prototype; + +var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) { + var SYMBOL = wellKnownSymbol$1(KEY); + + var DELEGATES_TO_SYMBOL = !fails$1(function () { + // String methods call symbol-named RegEp methods + var O = {}; + O[SYMBOL] = function () { return 7; }; + return ''[KEY](O) !== 7; + }); + + var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$1(function () { + // Symbol-named RegExp methods call .exec + var execCalled = false; + var re = /a/; + + if (KEY === 'split') { + // We can't use real regex here since it causes deoptimization + // and serious performance degradation in V8 + // https://github.com/zloirock/core-js/issues/306 + re = {}; + // RegExp[@@split] doesn't call the regex's exec method, but first creates + // a new one. We need to return the patched regex when creating the new one. + re.constructor = {}; + re.constructor[SPECIES] = function () { return re; }; + re.flags = ''; + re[SYMBOL] = /./[SYMBOL]; + } + + re.exec = function () { + execCalled = true; + return null; + }; + + re[SYMBOL](''); + return !execCalled; + }); + + if ( + !DELEGATES_TO_SYMBOL || + !DELEGATES_TO_EXEC || + FORCED + ) { + var uncurriedNativeRegExpMethod = uncurryThis$4(/./[SYMBOL]); + var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { + var uncurriedNativeMethod = uncurryThis$4(nativeMethod); + var $exec = regexp.exec; + if ($exec === regexpExec$1 || $exec === RegExpPrototype.exec) { + if (DELEGATES_TO_SYMBOL && !forceStringMethod) { + // The native String method already delegates to @@method (this + // polyfilled function), leasing to infinite recursion. + // We avoid it by directly calling the native @@method method. + return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) }; + } + return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) }; + } + return { done: false }; + }); + + defineBuiltIn(String.prototype, KEY, methods[0]); + defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]); + } + + if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true); +}; + +var charAt$1 = stringMultibyte.charAt; + +// `AdvanceStringIndex` abstract operation +// https://tc39.es/ecma262/#sec-advancestringindex +var advanceStringIndex$1 = function (S, index, unicode) { + return index + (unicode ? charAt$1(S, index).length : 1); +}; + +var uncurryThis$3 = functionUncurryThis; +var toObject = toObject$a; + +var floor = Math.floor; +var charAt = uncurryThis$3(''.charAt); +var replace = uncurryThis$3(''.replace); +var stringSlice$1 = uncurryThis$3(''.slice); +// eslint-disable-next-line redos/no-vulnerable -- safe +var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g; +var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g; + +// `GetSubstitution` abstract operation +// https://tc39.es/ecma262/#sec-getsubstitution +var getSubstitution$1 = function (matched, str, position, captures, namedCaptures, replacement) { + var tailPos = position + matched.length; + var m = captures.length; + var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; + if (namedCaptures !== undefined) { + namedCaptures = toObject(namedCaptures); + symbols = SUBSTITUTION_SYMBOLS; + } + return replace(replacement, symbols, function (match, ch) { + var capture; + switch (charAt(ch, 0)) { + case '$': return '$'; + case '&': return matched; + case '`': return stringSlice$1(str, 0, position); + case "'": return stringSlice$1(str, tailPos); + case '<': + capture = namedCaptures[stringSlice$1(ch, 1, -1)]; + break; + default: // \d\d? + var n = +ch; + if (n === 0) return match; + if (n > m) { + var f = floor(n / 10); + if (f === 0) return match; + if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1); + return match; + } + capture = captures[n - 1]; + } + return capture === undefined ? '' : capture; + }); +}; + +var call$1 = functionCall; +var anObject$1 = anObject$f; +var isCallable$1 = isCallable$o; +var classof = classofRaw$2; +var regexpExec = regexpExec$2; + +var $TypeError = TypeError; + +// `RegExpExec` abstract operation +// https://tc39.es/ecma262/#sec-regexpexec +var regexpExecAbstract = function (R, S) { + var exec = R.exec; + if (isCallable$1(exec)) { + var result = call$1(exec, R, S); + if (result !== null) anObject$1(result); + return result; + } + if (classof(R) === 'RegExp') return call$1(regexpExec, R, S); + throw new $TypeError('RegExp#exec called on incompatible receiver'); +}; + +var apply = functionApply; +var call = functionCall; +var uncurryThis$2 = functionUncurryThis; +var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic; +var fails = fails$u; +var anObject = anObject$f; +var isCallable = isCallable$o; +var isNullOrUndefined = isNullOrUndefined$8; +var toIntegerOrInfinity = toIntegerOrInfinity$4; +var toLength = toLength$3; +var toString$1 = toString$9; +var requireObjectCoercible$1 = requireObjectCoercible$7; +var advanceStringIndex = advanceStringIndex$1; +var getMethod = getMethod$4; +var getSubstitution = getSubstitution$1; +var regExpExec$1 = regexpExecAbstract; +var wellKnownSymbol = wellKnownSymbol$m; + +var REPLACE = wellKnownSymbol('replace'); +var max = Math.max; +var min = Math.min; +var concat = uncurryThis$2([].concat); +var push = uncurryThis$2([].push); +var stringIndexOf$1 = uncurryThis$2(''.indexOf); +var stringSlice = uncurryThis$2(''.slice); + +var maybeToString = function (it) { + return it === undefined ? it : String(it); +}; + +// IE <= 11 replaces $0 with the whole match, as if it was $& +// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0 +var REPLACE_KEEPS_$0 = (function () { + // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing + return 'a'.replace(/./, '$0') === '$0'; +})(); + +// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string +var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () { + if (/./[REPLACE]) { + return /./[REPLACE]('a', '$0') === ''; + } + return false; +})(); + +var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () { + var re = /./; + re.exec = function () { + var result = []; + result.groups = { a: '7' }; + return result; + }; + // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive + return ''.replace(re, '$') !== '7'; +}); + +// @@replace logic +fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) { + var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0'; + + return [ + // `String.prototype.replace` method + // https://tc39.es/ecma262/#sec-string.prototype.replace + function replace(searchValue, replaceValue) { + var O = requireObjectCoercible$1(this); + var replacer = isNullOrUndefined(searchValue) ? undefined : getMethod(searchValue, REPLACE); + return replacer + ? call(replacer, searchValue, O, replaceValue) + : call(nativeReplace, toString$1(O), searchValue, replaceValue); + }, + // `RegExp.prototype[@@replace]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace + function (string, replaceValue) { + var rx = anObject(this); + var S = toString$1(string); + + if ( + typeof replaceValue == 'string' && + stringIndexOf$1(replaceValue, UNSAFE_SUBSTITUTE) === -1 && + stringIndexOf$1(replaceValue, '$<') === -1 + ) { + var res = maybeCallNative(nativeReplace, rx, S, replaceValue); + if (res.done) return res.value; + } + + var functionalReplace = isCallable(replaceValue); + if (!functionalReplace) replaceValue = toString$1(replaceValue); + + var global = rx.global; + var fullUnicode; + if (global) { + fullUnicode = rx.unicode; + rx.lastIndex = 0; + } + + var results = []; + var result; + while (true) { + result = regExpExec$1(rx, S); + if (result === null) break; + + push(results, result); + if (!global) break; + + var matchStr = toString$1(result[0]); + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); + } + + var accumulatedResult = ''; + var nextSourcePosition = 0; + for (var i = 0; i < results.length; i++) { + result = results[i]; + + var matched = toString$1(result[0]); + var position = max(min(toIntegerOrInfinity(result.index), S.length), 0); + var captures = []; + var replacement; + // NOTE: This is equivalent to + // captures = result.slice(1).map(maybeToString) + // but for some reason `nativeSlice.call(result, 1, result.length)` (called in + // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and + // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. + for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j])); + var namedCaptures = result.groups; + if (functionalReplace) { + var replacerArgs = concat([matched], captures, position, S); + if (namedCaptures !== undefined) push(replacerArgs, namedCaptures); + replacement = toString$1(apply(replaceValue, undefined, replacerArgs)); + } else { + replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); + } + if (position >= nextSourcePosition) { + accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement; + nextSourcePosition = position + matched.length; + } + } + + return accumulatedResult + stringSlice(S, nextSourcePosition); + } + ]; +}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE); + +var _DataFetcher_instances, _DataFetcher_fetch; +var DataFetcher = /*#__PURE__*/function () { + function DataFetcher(calendar) { + _classCallCheck(this, DataFetcher); + _DataFetcher_instances.add(this); + this.calendar = calendar; + } + /** + * Fetch and interpret data from the datasource + * + * @param {string|object} source + * @param {number} startTimestamp + * @param {number} endTimestamp + * + * @return {Promize} A promise, that will return the final data when resolved + */ + _createClass(DataFetcher, [{ + key: "getDatas", + value: function getDatas(source, startTimestamp, endTimestamp) { + return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() { + var d; + return _regeneratorRuntime().wrap(function _callee$(_context) { + while (1) switch (_context.prev = _context.next) { + case 0: + if (!(typeof source === 'string' && source.length > 0)) { + _context.next = 2; + break; + } + return _context.abrupt("return", __classPrivateFieldGet(this, _DataFetcher_instances, "m", _DataFetcher_fetch).call(this, source, startTimestamp, endTimestamp)); + case 2: + d = []; + if (Array.isArray(source)) { + d = source; + } + return _context.abrupt("return", new Promise(function (resolve) { + resolve(d); + })); + case 5: + case "end": + return _context.stop(); + } + }, _callee, this); + })); + } + }, { + key: "parseURI", + value: function parseURI(str, startTimestamp, endTimestamp) { + var _this = this; + var newUri = str.replace(/\{\{start=(.*?)\}\}/g, function (_, format) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + _this.calendar.dateHelper.date(startTimestamp).format(format) + ); + }); + newUri = newUri.replace(/\{\{end=(.*?)\}\}/g, function (_, format) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + _this.calendar.dateHelper.date(endTimestamp).format(format) + ); + }); + return newUri; + } + }]); + return DataFetcher; +}(); +_DataFetcher_instances = new WeakSet(), _DataFetcher_fetch = function _DataFetcher_fetch(source, startTimestamp, endTimestamp) { + var _this$calendar$option = this.calendar.options.options.data, + type = _this$calendar$option.type, + requestInit = _this$calendar$option.requestInit; + var url = this.parseURI(source, startTimestamp, endTimestamp); + switch (type) { + case 'json': + return json(url, requestInit); + case 'csv': + return csv(url, requestInit); + case 'tsv': + return dsv('\t', url, requestInit); + case 'txt': + return text(url, requestInit); + default: + return new Promise(function (resolve) { + resolve([]); + }); + } +}; + +var DESCRIPTORS = descriptors; +var FUNCTION_NAME_EXISTS = functionName.EXISTS; +var uncurryThis$1 = functionUncurryThis; +var defineBuiltInAccessor = defineBuiltInAccessor$3; + +var FunctionPrototype = Function.prototype; +var functionToString = uncurryThis$1(FunctionPrototype.toString); +var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; +var regExpExec = uncurryThis$1(nameRE.exec); +var NAME = 'name'; + +// Function instances `.name` property +// https://tc39.es/ecma262/#sec-function-instances-name +if (DESCRIPTORS && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor(FunctionPrototype, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); +} + +var dayjs_min = {exports: {}}; + +(function (module, exports) { + !function(t,e){module.exports=e();}(commonjsGlobal,(function(){var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",c="month",f="quarter",h="year",d="date",l="Invalid Date",$=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function(t){var e=["th","st","nd","rd"],n=t%100;return "["+t+(e[(n-20)%10]||e[n]||e[0])+"]"}},m=function(t,e,n){var r=String(t);return !r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return (e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()1)return t(u[0])}else {var a=e.name;D[a]=e,i=a;}return !r&&i&&(g=i),i||!r&&g},O=function(t,e){if(S(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},b=v;b.l=w,b.i=S,b.w=function(t,e){return O(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=w(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[p]=!0;}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(b.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.init();},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds();},m.$utils=function(){return b},m.isValid=function(){return !(this.$d.toString()===l)},m.isSame=function(t,e){var n=O(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return O(t)25){var f=r(this).startOf(t).add(1,t).date(n),s=r(this).endOf(e);if(f.isBefore(s))return 1}var a=r(this).startOf(t).date(n).startOf(e).subtract(1,"millisecond"),o=this.diff(a,e,!0);return o<0?r(this).startOf("week").week():Math.ceil(o)},f.weeks=function(e){return void 0===e&&(e=null),this.week(e)};}})); +} (weekOfYear$1)); + +var weekOfYearExports = weekOfYear$1.exports; +var weekOfYear = /*@__PURE__*/getDefaultExportFromCjs(weekOfYearExports); + +var dayOfYear$1 = {exports: {}}; + +(function (module, exports) { + !function(e,t){module.exports=t();}(commonjsGlobal,(function(){return function(e,t,n){t.prototype.dayOfYear=function(e){var t=Math.round((n(this).startOf("day")-n(this).startOf("year"))/864e5)+1;return null==e?t:this.add(e-t,"day")};}})); +} (dayOfYear$1)); + +var dayOfYearExports = dayOfYear$1.exports; +var dayOfYear = /*@__PURE__*/getDefaultExportFromCjs(dayOfYearExports); + +var weekday$1 = {exports: {}}; + +(function (module, exports) { + !function(e,t){module.exports=t();}(commonjsGlobal,(function(){return function(e,t){t.prototype.weekday=function(e){var t=this.$locale().weekStart||0,i=this.$W,n=(i0&&(n=n[0]);t=(n=n.filter((function(e){return e})))[0];for(var i=1;i4&&(o+=7),n.add(o,e));return r.diff(u,"week")+1},d.isoWeekday=function(e){return this.$utils().u(e)?this.day()||7:this.day(this.day()%7?e:e-7)};var n=d.startOf;d.startOf=function(e,t){var i=this.$utils(),s=!!i.u(t)||t;return "isoweek"===i.p(e)?s?this.date(this.date()-(this.isoWeekday()-1)).startOf("day"):this.date(this.date()-1-(this.isoWeekday()-1)+7).endOf("day"):n.bind(this)(e,t)};}})); +} (isoWeek$1)); + +var isoWeekExports = isoWeek$1.exports; +var isoWeek = /*@__PURE__*/getDefaultExportFromCjs(isoWeekExports); + +var isLeapYear$1 = {exports: {}}; + +(function (module, exports) { + !function(e,t){module.exports=t();}(commonjsGlobal,(function(){return function(e,t){t.prototype.isLeapYear=function(){return this.$y%4==0&&this.$y%100!=0||this.$y%400==0};}})); +} (isLeapYear$1)); + +var isLeapYearExports = isLeapYear$1.exports; +var isLeapYear = /*@__PURE__*/getDefaultExportFromCjs(isLeapYearExports); + +var advancedFormat$1 = {exports: {}}; + +(function (module, exports) { + !function(e,t){module.exports=t();}(commonjsGlobal,(function(){return function(e,t){var r=t.prototype,n=r.format;r.format=function(e){var t=this,r=this.$locale();if(!this.isValid())return n.bind(this)(e);var s=this.$utils(),a=(e||"YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g,(function(e){switch(e){case"Q":return Math.ceil((t.$M+1)/3);case"Do":return r.ordinal(t.$D);case"gggg":return t.weekYear();case"GGGG":return t.isoWeekYear();case"wo":return r.ordinal(t.week(),"W");case"w":case"ww":return s.s(t.week(),"w"===e?1:2,"0");case"W":case"WW":return s.s(t.isoWeek(),"W"===e?1:2,"0");case"k":case"kk":return s.s(String(0===t.$H?24:t.$H),"k"===e?1:2,"0");case"X":return Math.floor(t.$d.getTime()/1e3);case"x":return t.$d.getTime();case"z":return "["+t.offsetName()+"]";case"zzz":return "["+t.offsetName("long")+"]";default:return e}}));return n.bind(this)(a)};}})); +} (advancedFormat$1)); + +var advancedFormatExports = advancedFormat$1.exports; +var advancedFormat = /*@__PURE__*/getDefaultExportFromCjs(advancedFormatExports); + +var utc$1 = {exports: {}}; + +(function (module, exports) { + !function(t,i){module.exports=i();}(commonjsGlobal,(function(){var t="minute",i=/[+-]\d\d(?::?\d\d)?/g,e=/([+-]|\d\d)/g;return function(s,f,n){var u=f.prototype;n.utc=function(t){var i={date:t,utc:!0,args:arguments};return new f(i)},u.utc=function(i){var e=n(this.toDate(),{locale:this.$L,utc:!0});return i?e.add(this.utcOffset(),t):e},u.local=function(){return n(this.toDate(),{locale:this.$L,utc:!1})};var o=u.parse;u.parse=function(t){t.utc&&(this.$u=!0),this.$utils().u(t.$offset)||(this.$offset=t.$offset),o.call(this,t);};var r=u.init;u.init=function(){if(this.$u){var t=this.$d;this.$y=t.getUTCFullYear(),this.$M=t.getUTCMonth(),this.$D=t.getUTCDate(),this.$W=t.getUTCDay(),this.$H=t.getUTCHours(),this.$m=t.getUTCMinutes(),this.$s=t.getUTCSeconds(),this.$ms=t.getUTCMilliseconds();}else r.call(this);};var a=u.utcOffset;u.utcOffset=function(s,f){var n=this.$utils().u;if(n(s))return this.$u?0:n(this.$offset)?a.call(this):this.$offset;if("string"==typeof s&&(s=function(t){void 0===t&&(t="");var s=t.match(i);if(!s)return null;var f=(""+s[0]).match(e)||["-",0,0],n=f[0],u=60*+f[1]+ +f[2];return 0===u?0:"+"===n?u:-u}(s),null===s))return this;var u=Math.abs(s)<=16?60*s:s,o=this;if(f)return o.$offset=u,o.$u=0===s,o;if(0!==s){var r=this.$u?this.toDate().getTimezoneOffset():-1*this.utcOffset();(o=this.local().add(u+r,t)).$offset=u,o.$x.$localOffset=r;}else o=this.utc();return o};var h=u.format;u.format=function(t){var i=t||(this.$u?"YYYY-MM-DDTHH:mm:ss[Z]":"");return h.call(this,i)},u.valueOf=function(){var t=this.$utils().u(this.$offset)?0:this.$offset+(this.$x.$localOffset||this.$d.getTimezoneOffset());return this.$d.valueOf()-6e4*t},u.isUTC=function(){return !!this.$u},u.toISOString=function(){return this.toDate().toISOString()},u.toString=function(){return this.toDate().toUTCString()};var l=u.toDate;u.toDate=function(t){return "s"===t&&this.$offset?n(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate():l.call(this)};var c=u.diff;u.diff=function(t,i,e){if(t&&this.$u===t.$u)return c.call(this,t,i,e);var s=this.local(),f=n(t).local();return c.call(s,f,i,e)};}})); +} (utc$1)); + +var utcExports = utc$1.exports; +var utc = /*@__PURE__*/getDefaultExportFromCjs(utcExports); + +var timezone$1 = {exports: {}}; + +(function (module, exports) { + !function(t,e){module.exports=e();}(commonjsGlobal,(function(){var t={year:0,month:1,day:2,hour:3,minute:4,second:5},e={};return function(n,i,o){var r,a=function(t,n,i){void 0===i&&(i={});var o=new Date(t),r=function(t,n){void 0===n&&(n={});var i=n.timeZoneName||"short",o=t+"|"+i,r=e[o];return r||(r=new Intl.DateTimeFormat("en-US",{hour12:!1,timeZone:t,year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",second:"2-digit",timeZoneName:i}),e[o]=r),r}(n,i);return r.formatToParts(o)},u=function(e,n){for(var i=a(e,n),r=[],u=0;u=0&&(r[c]=parseInt(m,10));}var d=r[3],l=24===d?0:d,h=r[0]+"-"+r[1]+"-"+r[2]+" "+l+":"+r[4]+":"+r[5]+":000",v=+e;return (o.utc(h).valueOf()-(v-=v%1e3))/6e4},f=i.prototype;f.tz=function(t,e){void 0===t&&(t=r);var n=this.utcOffset(),i=this.toDate(),a=i.toLocaleString("en-US",{timeZone:t}),u=Math.round((i-new Date(a))/1e3/60),f=o(a,{locale:this.$L}).$set("millisecond",this.$ms).utcOffset(15*-Math.round(i.getTimezoneOffset()/15)-u,!0);if(e){var s=f.utcOffset();f=f.add(n-s,"minute");}return f.$x.$timezone=t,f},f.offsetName=function(t){var e=this.$x.$timezone||o.tz.guess(),n=a(this.valueOf(),e,{timeZoneName:t}).find((function(t){return "timezonename"===t.type.toLowerCase()}));return n&&n.value};var s=f.startOf;f.startOf=function(t,e){if(!this.$x||!this.$x.$timezone)return s.call(this,t,e);var n=o(this.format("YYYY-MM-DD HH:mm:ss:SSS"),{locale:this.$L});return s.call(n,t,e).tz(this.$x.$timezone,!0)},o.tz=function(t,e,n){var i=n&&e,a=n||e||r,f=u(+o(),a);if("string"!=typeof t)return o(t).tz(a);var s=function(t,e,n){var i=t-60*e*1e3,o=u(i,n);if(e===o)return [i,e];var r=u(i-=60*(o-e)*1e3,n);return o===r?[i,o]:[t-60*Math.min(o,r)*1e3,Math.max(o,r)]}(o.utc(t,i).valueOf(),f,a),m=s[0],c=s[1],d=o(m).utcOffset(c);return d.$x.$timezone=a,d},o.tz.guess=function(){return Intl.DateTimeFormat().resolvedOptions().timeZone},o.tz.setDefault=function(t){r=t;};}})); +} (timezone$1)); + +var timezoneExports = timezone$1.exports; +var timezone = /*@__PURE__*/getDefaultExportFromCjs(timezoneExports); + +var localeData$1 = {exports: {}}; + +(function (module, exports) { + !function(n,e){module.exports=e();}(commonjsGlobal,(function(){return function(n,e,t){var r=e.prototype,o=function(n){return n&&(n.indexOf?n:n.s)},u=function(n,e,t,r,u){var i=n.name?n:n.$locale(),a=o(i[e]),s=o(i[t]),f=a||s.map((function(n){return n.slice(0,r)}));if(!u)return f;var d=i.weekStart;return f.map((function(n,e){return f[(e+(d||0))%7]}))},i=function(){return t.Ls[t.locale()]},a=function(n,e){return n.formats[e]||function(n){return n.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(n,e,t){return e||t.slice(1)}))}(n.formats[e.toUpperCase()])},s=function(){var n=this;return {months:function(e){return e?e.format("MMMM"):u(n,"months")},monthsShort:function(e){return e?e.format("MMM"):u(n,"monthsShort","months",3)},firstDayOfWeek:function(){return n.$locale().weekStart||0},weekdays:function(e){return e?e.format("dddd"):u(n,"weekdays")},weekdaysMin:function(e){return e?e.format("dd"):u(n,"weekdaysMin","weekdays",2)},weekdaysShort:function(e){return e?e.format("ddd"):u(n,"weekdaysShort","weekdays",3)},longDateFormat:function(e){return a(n.$locale(),e)},meridiem:this.$locale().meridiem,ordinal:this.$locale().ordinal}};r.localeData=function(){return s.bind(this)()},t.localeData=function(){var n=i();return {firstDayOfWeek:function(){return n.weekStart||0},weekdays:function(){return t.weekdays()},weekdaysShort:function(){return t.weekdaysShort()},weekdaysMin:function(){return t.weekdaysMin()},months:function(){return t.months()},monthsShort:function(){return t.monthsShort()},longDateFormat:function(e){return a(n,e)},meridiem:n.meridiem,ordinal:n.ordinal}},t.months=function(){return u(i(),"months")},t.monthsShort=function(){return u(i(),"monthsShort","months",3)},t.weekdays=function(n){return u(i(),"weekdays",null,null,n)},t.weekdaysShort=function(n){return u(i(),"weekdaysShort","weekdays",3,n)},t.weekdaysMin=function(n){return u(i(),"weekdaysMin","weekdays",2,n)};}})); +} (localeData$1)); + +var localeDataExports = localeData$1.exports; +var localeData = /*@__PURE__*/getDefaultExportFromCjs(localeDataExports); + +var localizedFormat$1 = {exports: {}}; + +(function (module, exports) { + !function(e,t){module.exports=t();}(commonjsGlobal,(function(){var e={LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"};return function(t,o,n){var r=o.prototype,i=r.format;n.en.formats=e,r.format=function(t){void 0===t&&(t="YYYY-MM-DDTHH:mm:ssZ");var o=this.$locale().formats,n=function(t,o){return t.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g,(function(t,n,r){var i=r&&r.toUpperCase();return n||o[r]||e[r]||o[i].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(e,t,o){return t||o.slice(1)}))}))}(t,void 0===o?{}:o);return i.call(this,n)};}})); +} (localizedFormat$1)); + +var localizedFormatExports = localizedFormat$1.exports; +var localizedFormat = /*@__PURE__*/getDefaultExportFromCjs(localizedFormatExports); + +var updateLocale$1 = {exports: {}}; + +(function (module, exports) { + !function(e,n){module.exports=n();}(commonjsGlobal,(function(){return function(e,n,t){t.updateLocale=function(e,n){var o=t.Ls[e];if(o)return (n?Object.keys(n):[]).forEach((function(e){o[e]=n[e];})),o};}})); +} (updateLocale$1)); + +var updateLocaleExports = updateLocale$1.exports; +var updateLocale = /*@__PURE__*/getDefaultExportFromCjs(updateLocaleExports); + +dayjs.extend(weekOfYear); +dayjs.extend(isoWeeksInYear); +dayjs.extend(isoWeek); +dayjs.extend(isLeapYear); +dayjs.extend(dayOfYear); +dayjs.extend(weekday); +dayjs.extend(minMax); +dayjs.extend(advancedFormat); +dayjs.extend(utc); +dayjs.extend(timezone); +dayjs.extend(localeData); +dayjs.extend(localizedFormat); +dayjs.extend(updateLocale); +var DEFAULT_LOCALE = 'en'; +var DateHelper = /*#__PURE__*/function () { + function DateHelper() { + _classCallCheck(this, DateHelper); + var _a; + this.locale = DEFAULT_LOCALE; + this.timezone = dayjs.tz.guess(); + if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object') { + (_a = window).dayjs || (_a.dayjs = dayjs); + } + } + _createClass(DateHelper, [{ + key: "setup", + value: function setup(_ref) { + var options = _ref.options; + return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() { + var userLocale, locale; + return _regeneratorRuntime().wrap(function _callee$(_context) { + while (1) switch (_context.prev = _context.next) { + case 0: + this.timezone = options.date.timezone || dayjs.tz.guess(); + userLocale = options.date.locale; + if (!(typeof userLocale === 'string' && userLocale !== DEFAULT_LOCALE)) { + _context.next = 17; + break; + } + if (!((typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object')) { + _context.next = 12; + break; + } + _context.t0 = window["dayjs_locale_".concat(userLocale)]; + if (_context.t0) { + _context.next = 9; + break; + } + _context.next = 8; + return this.loadBrowserLocale(userLocale); + case 8: + _context.t0 = _context.sent; + case 9: + locale = _context.t0; + _context.next = 15; + break; + case 12: + _context.next = 14; + return this.loadNodeLocale(userLocale); + case 14: + locale = _context.sent; + case 15: + dayjs.locale(userLocale); + this.locale = locale; + case 17: + if (_typeof(userLocale) === 'object') { + if (userLocale.hasOwnProperty('name')) { + dayjs.locale(userLocale.name, userLocale); + this.locale = userLocale; + } else { + this.locale = dayjs.updateLocale(DEFAULT_LOCALE, userLocale); + } + } + case 18: + case "end": + return _context.stop(); + } + }, _callee, this); + })); + } + // eslint-disable-next-line class-methods-use-this + }, { + key: "extend", + value: function extend(dayjsPlugin) { + return dayjs.extend(dayjsPlugin); + } + /** + * Return the week number, relative to its month + * + * @param {number|Date} d Date or timestamp in milliseconds + * @returns {number} The week number, relative to the month [0-5] + */ + }, { + key: "getMonthWeekNumber", + value: function getMonthWeekNumber(d) { + var dayjsDate = this.date(d); + var date = dayjsDate.startOf('day'); + var endOfWeek = dayjsDate.startOf('month').endOf('week'); + if (date <= endOfWeek) { + return 1; + } + return Math.ceil(date.diff(endOfWeek, 'weeks', true)) + 1; + } + /** + * Return the number of weeks in the given month + * + * As there is no fixed standard to specify which month a partial week should + * belongs to, the ISO week date standard is used, where: + * - the first week of the month should have at least 4 days + * + * @see https://en.wikipedia.org/wiki/ISO_week_date + * + * @param {Timestamp | dayjs.Dayjs} d Datejs object or timestamp + * @return {number} The number of weeks + */ + }, { + key: "getWeeksCountInMonth", + value: function getWeeksCountInMonth(d) { + var pivotDate = this.date(d); + return this.getLastWeekOfMonth(pivotDate).diff(this.getFirstWeekOfMonth(pivotDate), 'week') + 1; + } + /** + * Return the start of the first week of the month + * + * @see getWeeksCountInMonth() about standard warning + * @return {dayjs.Dayjs} A dayjs object representing the start of the + * first week + */ + }, { + key: "getFirstWeekOfMonth", + value: function getFirstWeekOfMonth(d) { + var startOfMonth = this.date(d).startOf('month'); + var startOfFirstWeek = startOfMonth.startOf('week'); + if (startOfMonth.weekday() > 4) { + startOfFirstWeek = startOfFirstWeek.add(1, 'week'); + } + return startOfFirstWeek; + } + /** + * Return the end of the last week of the month + * + * @see getWeeksCountInMonth() about standard warning + * @return {dayjs.Dayjs} A dayjs object representing the end of the last week + */ + }, { + key: "getLastWeekOfMonth", + value: function getLastWeekOfMonth(d) { + var endOfMonth = this.date(d).endOf('month'); + var endOfLastWeek = endOfMonth.endOf('week'); + if (endOfMonth.weekday() < 4) { + endOfLastWeek = endOfLastWeek.subtract(1, 'week'); + } + return endOfLastWeek; + } + }, { + key: "date", + value: function date() { + var d = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date(); + if (dayjs.isDayjs(d)) { + return d; + } + return dayjs(d).tz(this.timezone).utcOffset(0).locale(this.locale); + } + }, { + key: "format", + value: function format(timestamp, formatter) { + if (typeof formatter === 'function') { + for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { + args[_key - 2] = arguments[_key]; + } + return formatter.apply(void 0, [timestamp].concat(args)); + } + if (typeof formatter === 'string') { + return this.date(timestamp).format(formatter); + } + return null; + } + /** + * Return an array of time interval + * + * @param {number|Date} date A random date included in the wanted interval + * @param {number|Date} range Length of the wanted interval, or a stop date. + * @param {boolean} range Whether the end date should be excluded + * from the result + * @returns {Array} Array of unix timestamp, in milliseconds + */ + }, { + key: "intervals", + value: function intervals(interval, date, range) { + var excludeEnd = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + var start = this.date(date); + var end; + if (typeof range === 'number') { + end = start.add(range, interval); + } else if (dayjs.isDayjs(range)) { + end = range; + } else { + end = this.date(range); + } + start = start.startOf(interval); + end = end.startOf(interval); + var pivot = dayjs.min(start, end); + end = dayjs.max(start, end); + var result = []; + if (!excludeEnd) { + end = end.add(1, 'second'); + } + do { + result.push(+pivot); + pivot = pivot.add(1, interval); + } while (pivot < end); + return result; + } + // this function will work cross-browser for loading scripts asynchronously + // eslint-disable-next-line class-methods-use-this + }, { + key: "loadBrowserLocale", + value: function loadBrowserLocale(userLocale) { + return new Promise(function (resolve, reject) { + var s = document.createElement('script'); + s.type = 'text/javascript'; + s.async = true; + s.src = "https://cdn.jsdelivr.net/npm/dayjs@1/locale/".concat(userLocale, ".js"); + s.onerror = function (err) { + reject(err); + }; + s.onload = function () { + resolve(window["dayjs_locale_".concat(userLocale)]); + }; + document.head.appendChild(s); + }); + } + // eslint-disable-next-line class-methods-use-this + }, { + key: "loadNodeLocale", + value: function loadNodeLocale(userLocale) { + return import("dayjs/locale/".concat(userLocale, ".js")); + } + }]); + return DateHelper; +}(); + +var $ = _export; +var uncurryThis = functionUncurryThis; +var notARegExp = notARegexp; +var requireObjectCoercible = requireObjectCoercible$7; +var toString = toString$9; +var correctIsRegExpLogic = correctIsRegexpLogic; + +var stringIndexOf = uncurryThis(''.indexOf); + +// `String.prototype.includes` method +// https://tc39.es/ecma262/#sec-string.prototype.includes +$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, { + includes: function includes(searchString /* , position = 0 */) { + return !!~stringIndexOf( + toString(requireObjectCoercible(this)), + toString(notARegExp(searchString)), + arguments.length > 1 ? arguments[1] : undefined + ); + } +}); + +var ALLOWED_DATA_TYPES = ['json', 'csv', 'tsv', 'txt']; +/** + * Ensure that critical options are valid + * + * @throw {Error} on critical invalid options + * @return {boolean} Returns true when there is not critical errors + */ +function validate(templateCollection, _ref) { + var domain = _ref.domain, + subDomain = _ref.subDomain, + data = _ref.data; + var domainType = domain.type; + var subDomainType = subDomain.type; + if (!templateCollection.has(domainType)) { + throw new Error("'".concat(domainType, "' is not a valid domain type'")); + } + if (!templateCollection.has(subDomainType)) { + throw new Error("'".concat(subDomainType, "' is not a valid subDomain type'")); + } + if (data.type && !ALLOWED_DATA_TYPES.includes(data.type)) { + throw new Error("The data type '".concat(data.type, "' is not valid data type")); + } + if (!(templateCollection.get(subDomainType).allowedDomainType || []).includes(domainType)) { + throw new Error("The subDomain.type '".concat(subDomainType, "' can not be used together ") + "with the domain type ".concat(domainType)); + } + return true; +} + +var collection = collection$3; +var collectionStrong = collectionStrong$2; + +// `Set` constructor +// https://tc39.es/ecma262/#sec-set-objects +collection('Set', function (init) { + return function Set() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionStrong); + +function createPlugin(Creator, calendar) { + return new Creator(calendar); +} +function extractPluginName(PluginClass, options) { + return "".concat(new PluginClass().name).concat((options === null || options === void 0 ? void 0 : options.key) || ''); +} +var PluginManager = /*#__PURE__*/function () { + function PluginManager(calendar) { + _classCallCheck(this, PluginManager); + this.calendar = calendar; + this.settings = new Map(); + this.plugins = new Map(); + this.pendingPaint = new Set(); + } + _createClass(PluginManager, [{ + key: "add", + value: function add(plugins) { + var _this = this; + plugins.forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + PluginClass = _ref2[0], + pluginOptions = _ref2[1]; + var name = extractPluginName(PluginClass, pluginOptions); + var existingPlugin = _this.plugins.get(name); + if (existingPlugin && _this.settings.get(name) && isEqual(_this.settings.get(name).options, pluginOptions)) { + return; + } + _this.settings.set(name, { + options: pluginOptions, + dirty: true + }); + if (!_this.plugins.has(name)) { + _this.plugins.set(name, createPlugin(PluginClass, _this.calendar)); + } + _this.pendingPaint.add(_this.plugins.get(name)); + }); + } + }, { + key: "setupAll", + value: function setupAll() { + var _this2 = this; + this.plugins.forEach(function (pluginInstance, name) { + var settings = _this2.settings.get(name); + if (typeof settings !== 'undefined') { + if (settings.dirty) { + pluginInstance.setup(settings.options); + settings.dirty = false; + _this2.settings.set(name, settings); + } + } + }); + } + }, { + key: "paintAll", + value: function paintAll() { + return Array.from(this.pendingPaint.values()).map(function (p) { + return p.paint(); + }); + } + }, { + key: "destroyAll", + value: function destroyAll() { + return this.allPlugins().map(function (p) { + return p.destroy(); + }); + } + }, { + key: "getFromPosition", + value: function getFromPosition(position) { + return this.allPlugins().filter(function (plugin) { + var _a; + // eslint-disable-next-line implicit-arrow-linebreak + return ((_a = plugin.options) === null || _a === void 0 ? void 0 : _a.position) === position; + }); + } + }, { + key: "getHeightFromPosition", + value: function getHeightFromPosition(position) { + return this.getFromPosition(position).map(function (d) { + return d.options.dimensions.height; + }).reduce(function (a, b) { + return a + b; + }, 0); + } + }, { + key: "getWidthFromPosition", + value: function getWidthFromPosition(position) { + return this.getFromPosition(position).map(function (d) { + return d.options.dimensions.width; + }).reduce(function (a, b) { + return a + b; + }, 0); + } + }, { + key: "allPlugins", + value: function allPlugins() { + return Array.from(this.plugins.values()); + } + }]); + return PluginManager; +}(); + +var VERSION = '4.2.4'; + +var minuteTemplate = function minuteTemplate(DateHelper) { + var COLUMNS_COUNT = 10; + var ROWS_COUNT = 6; + var ALLOWED_DOMAIN_TYPE = ['day', 'hour']; + return { + name: 'minute', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return COLUMNS_COUNT; + }, + columnsCount: function columnsCount() { + return ROWS_COUNT; + }, + mapping: function mapping(startTimestamp, endTimestamp) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + DateHelper.intervals('minute', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts, index) { + return { + t: ts, + x: Math.floor(index / COLUMNS_COUNT), + y: index % COLUMNS_COUNT + }; + }) + ); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('minute').valueOf(); + } + }; +}; + +var hourTemplate = function hourTemplate(DateHelper, _ref) { + var domain = _ref.domain; + var TOTAL_ITEMS = 24; + var ROWS_COUNT = 6; + var ALLOWED_DOMAIN_TYPE = ['month', 'week', 'day']; + return { + name: 'hour', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return ROWS_COUNT; + }, + columnsCount: function columnsCount(ts) { + switch (domain.type) { + case 'week': + return TOTAL_ITEMS / ROWS_COUNT * 7; + case 'month': + return TOTAL_ITEMS / ROWS_COUNT * (domain.dynamicDimension ? DateHelper.date(ts).daysInMonth() : 31); + case 'day': + default: + return TOTAL_ITEMS / ROWS_COUNT; + } + }, + mapping: function mapping(startTimestamp, endTimestamp) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + DateHelper.intervals('hour', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts) { + var date = DateHelper.date(ts); + var hour = date.hour(); + var monthDate = date.date(); + var baseX = Math.floor(hour / ROWS_COUNT); + var columnOffset = TOTAL_ITEMS / ROWS_COUNT; + if (domain.type === 'month') { + baseX += (monthDate - 1) * columnOffset; + } + if (domain.type === 'week') { + baseX += +date.format('d') * columnOffset; + } + return { + t: ts, + x: baseX, + y: Math.floor(hour % ROWS_COUNT) + }; + }) + ); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('hour').valueOf(); + } + }; +}; + +var dayTemplate$2 = function dayTemplate(DateHelper, _ref) { + var domain = _ref.domain, + verticalOrientation = _ref.verticalOrientation; + var ROWS_COUNT = 7; + var ALLOWED_DOMAIN_TYPE = ['year', 'month', 'week']; + return { + name: 'day', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return domain.type === 'week' ? 1 : ROWS_COUNT; + }, + columnsCount: function columnsCount(ts) { + switch (domain.type) { + case 'month': + return Math.ceil(domain.dynamicDimension && !verticalOrientation ? DateHelper.getMonthWeekNumber(DateHelper.date(ts).endOf('month')) : 6); + case 'year': + return Math.ceil(domain.dynamicDimension ? DateHelper.date(ts).endOf('year').dayOfYear() / ROWS_COUNT : 54); + case 'week': + default: + return ROWS_COUNT; + } + }, + mapping: function mapping(startTimestamp, endTimestamp) { + var weekNumber = 0; + var x = -1; + return DateHelper.intervals('day', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts) { + var date = DateHelper.date(ts); + switch (domain.type) { + case 'month': + x = DateHelper.getMonthWeekNumber(ts) - 1; + break; + case 'year': + if (weekNumber !== date.week()) { + weekNumber = date.week(); + x += 1; + } + break; + case 'week': + x = date.weekday(); + break; + } + return { + t: ts, + x: x, + y: domain.type === 'week' ? 0 : date.weekday() + }; + }); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('day').valueOf(); + } + }; +}; + +var dayTemplate$1 = function dayTemplate(DateHelper, _ref) { + var domain = _ref.domain, + verticalOrientation = _ref.verticalOrientation; + var COLUMNS_COUNT = 7; + var ALLOWED_DOMAIN_TYPE = ['year', 'month', 'week']; + return { + name: 'xDay', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount(ts) { + switch (domain.type) { + case 'month': + return Math.ceil(domain.dynamicDimension && !verticalOrientation ? DateHelper.getMonthWeekNumber(DateHelper.date(ts).endOf('month')) : 6); + case 'year': + return Math.ceil(domain.dynamicDimension ? DateHelper.date(ts).endOf('year').dayOfYear() / COLUMNS_COUNT : 54); + case 'week': + default: + return COLUMNS_COUNT; + } + }, + columnsCount: function columnsCount() { + if (domain.type === 'week') { + return 1; + } + return COLUMNS_COUNT; + }, + mapping: function mapping(startTimestamp, endTimestamp) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + DateHelper.intervals('day', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts) { + var date = DateHelper.date(ts); + var endWeekNumber = date.endOf('year').week(); + var x = 0; + switch (domain.type) { + case 'month': + x = DateHelper.getMonthWeekNumber(ts) - 1; + break; + case 'year': + if (endWeekNumber === 1 && date.week() === endWeekNumber) { + x = date.subtract(1, 'week').week() + 1; + } + x = date.week() - 1; + break; + case 'week': + x = date.weekday(); + break; + } + return { + t: ts, + y: x, + x: domain.type === 'week' ? 0 : date.weekday() + }; + }) + ); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('day').valueOf(); + } + }; +}; + +var dayTemplate = function dayTemplate(DateHelper) { + var ROWS_COUNT = 7; + var ALLOWED_DOMAIN_TYPE = ['month']; + return { + name: 'ghDay', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return ROWS_COUNT; + }, + columnsCount: function columnsCount(ts) { + return DateHelper.getWeeksCountInMonth(ts); + }, + mapping: function mapping(startTimestamp, endTimestamp) { + var clampStart = DateHelper.getFirstWeekOfMonth(startTimestamp); + var clampEnd = DateHelper.getFirstWeekOfMonth(endTimestamp); + var x = -1; + var pivotDay = clampStart.weekday(); + return DateHelper.intervals('day', clampStart, clampEnd).map(function (ts) { + var weekday = DateHelper.date(ts).weekday(); + if (weekday === pivotDay) { + x += 1; + } + return { + t: ts, + x: x, + y: weekday + }; + }); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('day').valueOf(); + } + }; +}; + +var weekTemplate = function weekTemplate(DateHelper, _ref) { + var domain = _ref.domain; + var ALLOWED_DOMAIN_TYPE = ['year', 'month']; + return { + name: 'week', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return 1; + }, + columnsCount: function columnsCount(ts) { + switch (domain.type) { + case 'year': + return domain.dynamicDimension ? DateHelper.date(ts).endOf('year').isoWeeksInYear() : 53; + case 'month': + return domain.dynamicDimension ? DateHelper.getWeeksCountInMonth(ts) : 5; + default: + return 1; + } + }, + mapping: function mapping(startTimestamp, endTimestamp) { + var clampStart = DateHelper.getFirstWeekOfMonth(startTimestamp); + var clampEnd = DateHelper.getFirstWeekOfMonth(endTimestamp); + return DateHelper.intervals('week', clampStart, clampEnd).map(function (ts, i) { + return { + t: ts, + x: i, + y: 0 + }; + }); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('week').valueOf(); + } + }; +}; + +var monthTemplate = function monthTemplate(DateHelper) { + var ALLOWED_DOMAIN_TYPE = ['year']; + return { + name: 'month', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return 1; + }, + columnsCount: function columnsCount() { + return 12; + }, + mapping: function mapping(startTimestamp, endTimestamp) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + DateHelper.intervals('month', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts) { + return { + t: ts, + x: DateHelper.date(ts).month(), + y: 0 + }; + }) + ); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('month').valueOf(); + } + }; +}; + +var yearTemplate = function yearTemplate(DateHelper) { + var ALLOWED_DOMAIN_TYPE = []; + return { + name: 'year', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return 1; + }, + columnsCount: function columnsCount() { + return 1; + }, + mapping: function mapping(startTimestamp, endTimestamp) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + DateHelper.intervals('year', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts, index) { + return { + t: ts, + x: index, + y: 0 + }; + }) + ); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('year').valueOf(); + } + }; +}; + +var DefaultTemplates = [minuteTemplate, hourTemplate, dayTemplate$2, dayTemplate$1, dayTemplate, weekTemplate, monthTemplate, yearTemplate]; + +var TemplateCollection = /*#__PURE__*/function () { + function TemplateCollection(dateHelper, options) { + _classCallCheck(this, TemplateCollection); + this.settings = new Map(); + this.dateHelper = dateHelper; + this.options = options; + this.initiated = false; + } + _createClass(TemplateCollection, [{ + key: "get", + value: function get(subDomainType) { + return this.settings.get(subDomainType); + } + }, { + key: "has", + value: function has(subDomainType) { + return this.settings.has(subDomainType); + } + }, { + key: "init", + value: function init() { + if (!this.initiated) { + this.initiated = true; + this.add(DefaultTemplates); + } + } + }, { + key: "add", + value: function add(templates) { + var _this = this; + this.init(); + var tplWithParent = []; + castArray(templates).forEach(function (f) { + var template = f(_this.dateHelper, _this.options.options); + _this.settings.set(template.name, template); + if (template.hasOwnProperty('parent')) { + tplWithParent.push(template.name); + } + }); + tplWithParent.forEach(function (name) { + var parentTemplate = _this.settings.get(_this.settings.get(name).parent); + if (!parentTemplate) { + return; + } + _this.settings.set(name, Object.assign(Object.assign({}, parentTemplate), _this.settings.get(name))); + }); + } + }]); + return TemplateCollection; +}(); + +var CalHeatmap = /*#__PURE__*/function () { + function CalHeatmap() { + _classCallCheck(this, CalHeatmap); + // Default options + this.options = new Options(); + // Init the helpers with the default options + this.dateHelper = new DateHelper(); + this.templateCollection = new TemplateCollection(this.dateHelper, this.options); + this.dataFetcher = new DataFetcher(this); + this.navigator = new Navigator(this); + this.populator = new Populator(this); + this.calendarPainter = new CalendarPainter(this); + this.eventEmitter = new EventEmitter(); + this.pluginManager = new PluginManager(this); + } + _createClass(CalHeatmap, [{ + key: "createDomainCollection", + value: function createDomainCollection(startDate, range) { + var excludeEnd = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + return new DomainCollection(this.dateHelper, this.options.options.domain.type, startDate, range, excludeEnd); + } + // ========================================================================= + // PUBLIC API + // ========================================================================= + /** + * Setup and paint the calendar with the given options + * + * @param {Object} options The Options object + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "paint", + value: function paint(options, plugins) { + return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() { + return _regeneratorRuntime().wrap(function _callee$(_context) { + while (1) switch (_context.prev = _context.next) { + case 0: + this.options.init(options); + _context.next = 3; + return this.dateHelper.setup(this.options); + case 3: + this.templateCollection.init(); + _context.prev = 4; + validate(this.templateCollection, this.options.options); + _context.next = 11; + break; + case 8: + _context.prev = 8; + _context.t0 = _context["catch"](4); + return _context.abrupt("return", Promise.reject(_context.t0)); + case 11: + if (plugins) { + this.pluginManager.add(castArray(plugins)); + } + this.calendarPainter.setup(); + // Record all the valid domains + // Each domain value is a timestamp in milliseconds + this.domainCollection = new DomainCollection(this.dateHelper); + this.navigator.loadNewDomains(this.createDomainCollection(this.options.options.date.start, this.options.options.range)); + return _context.abrupt("return", Promise.allSettled([this.calendarPainter.paint(), this.fill()])); + case 16: + case "end": + return _context.stop(); + } + }, _callee, this, [[4, 8]]); + })); + } + /** + * Add a new subDomainTemplate + * + * @since 4.0.0 + * @param {SubDomainTemplate[] | SubDomainTemplate} templates + * A single, or an array of SubDomainTemplate object + * @return void + */ + }, { + key: "addTemplates", + value: function addTemplates(templates) { + this.templateCollection.add(templates); + } + /** + * Shift the calendar by n domains forward + * + * @param {number} n Number of domain intervals to shift forward + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "next", + value: function next() { + var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; + var loadDirection = this.navigator.loadNewDomains(this.createDomainCollection(this.domainCollection.max, n + 1).slice(n), ScrollDirection.SCROLL_FORWARD); + return Promise.allSettled([this.calendarPainter.paint(loadDirection), this.fill()]); + } + /** + * Shift the calendar by n domains backward + * + * @param {number} n Number of domain intervals to shift backward + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "previous", + value: function previous() { + var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; + var loadDirection = this.navigator.loadNewDomains(this.createDomainCollection(this.domainCollection.min, -n), ScrollDirection.SCROLL_BACKWARD); + return Promise.allSettled([this.calendarPainter.paint(loadDirection), this.fill()]); + } + /** + * Jump directly to a specific date + * + * JumpTo will scroll the calendar until the wanted domain with the specified + * date is visible. Unless you set reset to true, the wanted domain + * will not necessarily be the first domain of the calendar. + * + * @param {Date} date Jump to the domain containing that date + * @param {boolean} reset Whether the wanted domain + * should be the first domain of the calendar + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "jumpTo", + value: function jumpTo(date) { + var reset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + return Promise.allSettled([this.calendarPainter.paint(this.navigator.jumpTo(date, reset)), this.fill()]); + } + /** + * Fill the calendar with the given data + * + * @param {Object|string} dataSource The calendar's datasource, + * same type as `options.data.source` + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "fill", + value: function fill() { + var _this = this; + var dataSource = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.options.options.data.source; + var options = this.options.options; + var template = this.templateCollection; + var endDate = this.dateHelper.intervals(options.domain.type, this.domainCollection.max, 2)[1]; + var dataPromise = this.dataFetcher.getDatas(dataSource, this.domainCollection.min, endDate); + return new Promise(function (resolve, reject) { + dataPromise.then(function (data) { + _this.domainCollection.fill(data, options.data, template.get(options.subDomain.type).extractUnit); + _this.populator.populate(); + resolve(null); + }, function (error) { + reject(error); + }); + }); + } + /** + * Listener for all events + * + * @since 4.0.0 + * @param {string} eventName Name of the event to listen to + * @param {function} Callback function to execute on event trigger + * @return void + */ + }, { + key: "on", + value: function on(name, fn) { + this.eventEmitter.on(name, fn); + } + }, { + key: "dimensions", + value: function dimensions() { + return this.calendarPainter.dimensions; + } + /** + * Destroy the calendar + * + * @since 3.3.6 + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "destroy", + value: function destroy() { + return this.calendarPainter.destroy(); + } + }, { + key: "extendDayjs", + value: function extendDayjs(plugin) { + return this.dateHelper.extend(plugin); + } + }]); + return CalHeatmap; +}(); +CalHeatmap.VERSION = VERSION; + +export { CalHeatmap as default }; diff --git a/src/agenda_culturel/static/cal-heatmap/cal-heatmap.js b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.js new file mode 100644 index 0000000..a901a15 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.js @@ -0,0 +1,13214 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('d3-selection'), require('d3-color'), require('d3'), require('d3-fetch')) : + typeof define === 'function' && define.amd ? define(['d3-selection', 'd3-color', 'd3', 'd3-fetch'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.CalHeatmap = factory(global.d3, global.d3, global.d3, global.d3)); +})(this, (function (d3Selection, d3Color, d3, d3Fetch) { 'use strict'; + + function _iterableToArrayLimit(arr, i) { + var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; + if (null != _i) { + var _s, + _e, + _x, + _r, + _arr = [], + _n = !0, + _d = !1; + try { + if (_x = (_i = _i.call(arr)).next, 0 === i) { + if (Object(_i) !== _i) return; + _n = !1; + } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); + } catch (err) { + _d = !0, _e = err; + } finally { + try { + if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; + } finally { + if (_d) throw _e; + } + } + return _arr; + } + } + function _regeneratorRuntime() { + _regeneratorRuntime = function () { + return exports; + }; + var exports = {}, + Op = Object.prototype, + hasOwn = Op.hasOwnProperty, + defineProperty = Object.defineProperty || function (obj, key, desc) { + obj[key] = desc.value; + }, + $Symbol = "function" == typeof Symbol ? Symbol : {}, + iteratorSymbol = $Symbol.iterator || "@@iterator", + asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator", + toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag"; + function define(obj, key, value) { + return Object.defineProperty(obj, key, { + value: value, + enumerable: !0, + configurable: !0, + writable: !0 + }), obj[key]; + } + try { + define({}, ""); + } catch (err) { + define = function (obj, key, value) { + return obj[key] = value; + }; + } + function wrap(innerFn, outerFn, self, tryLocsList) { + var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator, + generator = Object.create(protoGenerator.prototype), + context = new Context(tryLocsList || []); + return defineProperty(generator, "_invoke", { + value: makeInvokeMethod(innerFn, self, context) + }), generator; + } + function tryCatch(fn, obj, arg) { + try { + return { + type: "normal", + arg: fn.call(obj, arg) + }; + } catch (err) { + return { + type: "throw", + arg: err + }; + } + } + exports.wrap = wrap; + var ContinueSentinel = {}; + function Generator() {} + function GeneratorFunction() {} + function GeneratorFunctionPrototype() {} + var IteratorPrototype = {}; + define(IteratorPrototype, iteratorSymbol, function () { + return this; + }); + var getProto = Object.getPrototypeOf, + NativeIteratorPrototype = getProto && getProto(getProto(values([]))); + NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype); + var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype); + function defineIteratorMethods(prototype) { + ["next", "throw", "return"].forEach(function (method) { + define(prototype, method, function (arg) { + return this._invoke(method, arg); + }); + }); + } + function AsyncIterator(generator, PromiseImpl) { + function invoke(method, arg, resolve, reject) { + var record = tryCatch(generator[method], generator, arg); + if ("throw" !== record.type) { + var result = record.arg, + value = result.value; + return value && "object" == typeof value && hasOwn.call(value, "__await") ? PromiseImpl.resolve(value.__await).then(function (value) { + invoke("next", value, resolve, reject); + }, function (err) { + invoke("throw", err, resolve, reject); + }) : PromiseImpl.resolve(value).then(function (unwrapped) { + result.value = unwrapped, resolve(result); + }, function (error) { + return invoke("throw", error, resolve, reject); + }); + } + reject(record.arg); + } + var previousPromise; + defineProperty(this, "_invoke", { + value: function (method, arg) { + function callInvokeWithMethodAndArg() { + return new PromiseImpl(function (resolve, reject) { + invoke(method, arg, resolve, reject); + }); + } + return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg(); + } + }); + } + function makeInvokeMethod(innerFn, self, context) { + var state = "suspendedStart"; + return function (method, arg) { + if ("executing" === state) throw new Error("Generator is already running"); + if ("completed" === state) { + if ("throw" === method) throw arg; + return doneResult(); + } + for (context.method = method, context.arg = arg;;) { + var delegate = context.delegate; + if (delegate) { + var delegateResult = maybeInvokeDelegate(delegate, context); + if (delegateResult) { + if (delegateResult === ContinueSentinel) continue; + return delegateResult; + } + } + if ("next" === context.method) context.sent = context._sent = context.arg;else if ("throw" === context.method) { + if ("suspendedStart" === state) throw state = "completed", context.arg; + context.dispatchException(context.arg); + } else "return" === context.method && context.abrupt("return", context.arg); + state = "executing"; + var record = tryCatch(innerFn, self, context); + if ("normal" === record.type) { + if (state = context.done ? "completed" : "suspendedYield", record.arg === ContinueSentinel) continue; + return { + value: record.arg, + done: context.done + }; + } + "throw" === record.type && (state = "completed", context.method = "throw", context.arg = record.arg); + } + }; + } + function maybeInvokeDelegate(delegate, context) { + var methodName = context.method, + method = delegate.iterator[methodName]; + if (undefined === method) return context.delegate = null, "throw" === methodName && delegate.iterator.return && (context.method = "return", context.arg = undefined, maybeInvokeDelegate(delegate, context), "throw" === context.method) || "return" !== methodName && (context.method = "throw", context.arg = new TypeError("The iterator does not provide a '" + methodName + "' method")), ContinueSentinel; + var record = tryCatch(method, delegate.iterator, context.arg); + if ("throw" === record.type) return context.method = "throw", context.arg = record.arg, context.delegate = null, ContinueSentinel; + var info = record.arg; + return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, "return" !== context.method && (context.method = "next", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = "throw", context.arg = new TypeError("iterator result is not an object"), context.delegate = null, ContinueSentinel); + } + function pushTryEntry(locs) { + var entry = { + tryLoc: locs[0] + }; + 1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry); + } + function resetTryEntry(entry) { + var record = entry.completion || {}; + record.type = "normal", delete record.arg, entry.completion = record; + } + function Context(tryLocsList) { + this.tryEntries = [{ + tryLoc: "root" + }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0); + } + function values(iterable) { + if (iterable) { + var iteratorMethod = iterable[iteratorSymbol]; + if (iteratorMethod) return iteratorMethod.call(iterable); + if ("function" == typeof iterable.next) return iterable; + if (!isNaN(iterable.length)) { + var i = -1, + next = function next() { + for (; ++i < iterable.length;) if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next; + return next.value = undefined, next.done = !0, next; + }; + return next.next = next; + } + } + return { + next: doneResult + }; + } + function doneResult() { + return { + value: undefined, + done: !0 + }; + } + return GeneratorFunction.prototype = GeneratorFunctionPrototype, defineProperty(Gp, "constructor", { + value: GeneratorFunctionPrototype, + configurable: !0 + }), defineProperty(GeneratorFunctionPrototype, "constructor", { + value: GeneratorFunction, + configurable: !0 + }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction"), exports.isGeneratorFunction = function (genFun) { + var ctor = "function" == typeof genFun && genFun.constructor; + return !!ctor && (ctor === GeneratorFunction || "GeneratorFunction" === (ctor.displayName || ctor.name)); + }, exports.mark = function (genFun) { + return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, "GeneratorFunction")), genFun.prototype = Object.create(Gp), genFun; + }, exports.awrap = function (arg) { + return { + __await: arg + }; + }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () { + return this; + }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) { + void 0 === PromiseImpl && (PromiseImpl = Promise); + var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl); + return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) { + return result.done ? result.value : iter.next(); + }); + }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, "Generator"), define(Gp, iteratorSymbol, function () { + return this; + }), define(Gp, "toString", function () { + return "[object Generator]"; + }), exports.keys = function (val) { + var object = Object(val), + keys = []; + for (var key in object) keys.push(key); + return keys.reverse(), function next() { + for (; keys.length;) { + var key = keys.pop(); + if (key in object) return next.value = key, next.done = !1, next; + } + return next.done = !0, next; + }; + }, exports.values = values, Context.prototype = { + constructor: Context, + reset: function (skipTempReset) { + if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = "next", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) "t" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined); + }, + stop: function () { + this.done = !0; + var rootRecord = this.tryEntries[0].completion; + if ("throw" === rootRecord.type) throw rootRecord.arg; + return this.rval; + }, + dispatchException: function (exception) { + if (this.done) throw exception; + var context = this; + function handle(loc, caught) { + return record.type = "throw", record.arg = exception, context.next = loc, caught && (context.method = "next", context.arg = undefined), !!caught; + } + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i], + record = entry.completion; + if ("root" === entry.tryLoc) return handle("end"); + if (entry.tryLoc <= this.prev) { + var hasCatch = hasOwn.call(entry, "catchLoc"), + hasFinally = hasOwn.call(entry, "finallyLoc"); + if (hasCatch && hasFinally) { + if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); + if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); + } else if (hasCatch) { + if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0); + } else { + if (!hasFinally) throw new Error("try statement without catch or finally"); + if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc); + } + } + } + }, + abrupt: function (type, arg) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) { + var finallyEntry = entry; + break; + } + } + finallyEntry && ("break" === type || "continue" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null); + var record = finallyEntry ? finallyEntry.completion : {}; + return record.type = type, record.arg = arg, finallyEntry ? (this.method = "next", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record); + }, + complete: function (record, afterLoc) { + if ("throw" === record.type) throw record.arg; + return "break" === record.type || "continue" === record.type ? this.next = record.arg : "return" === record.type ? (this.rval = this.arg = record.arg, this.method = "return", this.next = "end") : "normal" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel; + }, + finish: function (finallyLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel; + } + }, + catch: function (tryLoc) { + for (var i = this.tryEntries.length - 1; i >= 0; --i) { + var entry = this.tryEntries[i]; + if (entry.tryLoc === tryLoc) { + var record = entry.completion; + if ("throw" === record.type) { + var thrown = record.arg; + resetTryEntry(entry); + } + return thrown; + } + } + throw new Error("illegal catch attempt"); + }, + delegateYield: function (iterable, resultName, nextLoc) { + return this.delegate = { + iterator: values(iterable), + resultName: resultName, + nextLoc: nextLoc + }, "next" === this.method && (this.arg = undefined), ContinueSentinel; + } + }, exports; + } + function _typeof(obj) { + "@babel/helpers - typeof"; + + return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { + return typeof obj; + } : function (obj) { + return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }, _typeof(obj); + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; + } + function _defineProperty(obj, key, value) { + key = _toPropertyKey(key); + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; + } + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); + } + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + return arr2; + } + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); + } + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); + } + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + function getDefaultExportFromCjs (x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x; + } + + var check = function (it) { + return it && it.Math === Math && it; + }; + + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global$n = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + + var shared$4 = {exports: {}}; + + var global$m = global$n; + + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$9 = Object.defineProperty; + + var defineGlobalProperty$3 = function (key, value) { + try { + defineProperty$9(global$m, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$m[key] = value; + } return value; + }; + + var global$l = global$n; + var defineGlobalProperty$2 = defineGlobalProperty$3; + + var SHARED = '__core-js_shared__'; + var store$3 = global$l[SHARED] || defineGlobalProperty$2(SHARED, {}); + + var sharedStore = store$3; + + var store$2 = sharedStore; + + (shared$4.exports = function (key, value) { + return store$2[key] || (store$2[key] = value !== undefined ? value : {}); + })('versions', []).push({ + version: '3.34.0', + mode: 'global', + copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE', + source: 'https://github.com/zloirock/core-js' + }); + + var sharedExports = shared$4.exports; + + var fails$u = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } + }; + + var fails$t = fails$u; + + var functionBindNative = !fails$t(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); + }); + + var NATIVE_BIND$3 = functionBindNative; + + var FunctionPrototype$3 = Function.prototype; + var call$j = FunctionPrototype$3.call; + var uncurryThisWithBind = NATIVE_BIND$3 && FunctionPrototype$3.bind.bind(call$j, call$j); + + var functionUncurryThis = NATIVE_BIND$3 ? uncurryThisWithBind : function (fn) { + return function () { + return call$j.apply(fn, arguments); + }; + }; + + // we can't use just `it == null` since of `document.all` special case + // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec + var isNullOrUndefined$8 = function (it) { + return it === null || it === undefined; + }; + + var isNullOrUndefined$7 = isNullOrUndefined$8; + + var $TypeError$g = TypeError; + + // `RequireObjectCoercible` abstract operation + // https://tc39.es/ecma262/#sec-requireobjectcoercible + var requireObjectCoercible$7 = function (it) { + if (isNullOrUndefined$7(it)) throw new $TypeError$g("Can't call method on " + it); + return it; + }; + + var requireObjectCoercible$6 = requireObjectCoercible$7; + + var $Object$4 = Object; + + // `ToObject` abstract operation + // https://tc39.es/ecma262/#sec-toobject + var toObject$a = function (argument) { + return $Object$4(requireObjectCoercible$6(argument)); + }; + + var uncurryThis$u = functionUncurryThis; + var toObject$9 = toObject$a; + + var hasOwnProperty$d = uncurryThis$u({}.hasOwnProperty); + + // `HasOwnProperty` abstract operation + // https://tc39.es/ecma262/#sec-hasownproperty + // eslint-disable-next-line es/no-object-hasown -- safe + var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty$d(toObject$9(it), key); + }; + + var uncurryThis$t = functionUncurryThis; + + var id$2 = 0; + var postfix = Math.random(); + var toString$c = uncurryThis$t(1.0.toString); + + var uid$3 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$c(++id$2 + postfix, 36); + }; + + var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || ''; + + var global$k = global$n; + var userAgent$5 = engineUserAgent; + + var process$3 = global$k.process; + var Deno$1 = global$k.Deno; + var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version; + var v8 = versions && versions.v8; + var match, version; + + if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); + } + + // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` + // so check `userAgent` even if `.v8` exists, but 0 + if (!version && userAgent$5) { + match = userAgent$5.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$5.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } + } + + var engineV8Version = version; + + /* eslint-disable es/no-symbol -- required for testing */ + var V8_VERSION$3 = engineV8Version; + var fails$s = fails$u; + var global$j = global$n; + + var $String$5 = global$j.String; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing + var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$s(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String$5(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$3 && V8_VERSION$3 < 41; + }); + + /* eslint-disable es/no-symbol -- required for testing */ + var NATIVE_SYMBOL$1 = symbolConstructorDetection; + + var useSymbolAsUid = NATIVE_SYMBOL$1 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + + var global$i = global$n; + var shared$3 = sharedExports; + var hasOwn$b = hasOwnProperty_1; + var uid$2 = uid$3; + var NATIVE_SYMBOL = symbolConstructorDetection; + var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + + var Symbol$3 = global$i.Symbol; + var WellKnownSymbolsStore = shared$3('wks'); + var createWellKnownSymbol = USE_SYMBOL_AS_UID$1 ? Symbol$3['for'] || Symbol$3 : Symbol$3 && Symbol$3.withoutSetter || uid$2; + + var wellKnownSymbol$m = function (name) { + if (!hasOwn$b(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$b(Symbol$3, name) + ? Symbol$3[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; + }; + + var wellKnownSymbol$l = wellKnownSymbol$m; + + var TO_STRING_TAG$2 = wellKnownSymbol$l('toStringTag'); + var test$1 = {}; + + test$1[TO_STRING_TAG$2] = 'z'; + + var toStringTagSupport = String(test$1) === '[object z]'; + + var documentAll$2 = typeof document == 'object' && document.all; + + // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot + // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing + var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined; + + var documentAll_1 = { + all: documentAll$2, + IS_HTMLDDA: IS_HTMLDDA + }; + + var $documentAll$1 = documentAll_1; + + var documentAll$1 = $documentAll$1.all; + + // `IsCallable` abstract operation + // https://tc39.es/ecma262/#sec-iscallable + var isCallable$o = $documentAll$1.IS_HTMLDDA ? function (argument) { + return typeof argument == 'function' || argument === documentAll$1; + } : function (argument) { + return typeof argument == 'function'; + }; + + var objectDefineProperty = {}; + + var fails$r = fails$u; + + // Detect IE8's incomplete defineProperty implementation + var descriptors = !fails$r(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; + }); + + var isCallable$n = isCallable$o; + var $documentAll = documentAll_1; + + var documentAll = $documentAll.all; + + var isObject$j = $documentAll.IS_HTMLDDA ? function (it) { + return typeof it == 'object' ? it !== null : isCallable$n(it) || it === documentAll; + } : function (it) { + return typeof it == 'object' ? it !== null : isCallable$n(it); + }; + + var global$h = global$n; + var isObject$i = isObject$j; + + var document$3 = global$h.document; + // typeof document.createElement is 'object' in old IE + var EXISTS$1 = isObject$i(document$3) && isObject$i(document$3.createElement); + + var documentCreateElement$2 = function (it) { + return EXISTS$1 ? document$3.createElement(it) : {}; + }; + + var DESCRIPTORS$d = descriptors; + var fails$q = fails$u; + var createElement$1 = documentCreateElement$2; + + // Thanks to IE8 for its funny defineProperty + var ie8DomDefine = !DESCRIPTORS$d && !fails$q(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { + get: function () { return 7; } + }).a !== 7; + }); + + var DESCRIPTORS$c = descriptors; + var fails$p = fails$u; + + // V8 ~ Chrome 36- + // https://bugs.chromium.org/p/v8/issues/detail?id=3334 + var v8PrototypeDefineBug = DESCRIPTORS$c && fails$p(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; + }); + + var isObject$h = isObject$j; + + var $String$4 = String; + var $TypeError$f = TypeError; + + // `Assert: Type(argument) is Object` + var anObject$f = function (argument) { + if (isObject$h(argument)) return argument; + throw new $TypeError$f($String$4(argument) + ' is not an object'); + }; + + var NATIVE_BIND$2 = functionBindNative; + + var call$i = Function.prototype.call; + + var functionCall = NATIVE_BIND$2 ? call$i.bind(call$i) : function () { + return call$i.apply(call$i, arguments); + }; + + var global$g = global$n; + var isCallable$m = isCallable$o; + + var aFunction = function (argument) { + return isCallable$m(argument) ? argument : undefined; + }; + + var getBuiltIn$7 = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$g[namespace]) : global$g[namespace] && global$g[namespace][method]; + }; + + var uncurryThis$s = functionUncurryThis; + + var objectIsPrototypeOf = uncurryThis$s({}.isPrototypeOf); + + var getBuiltIn$6 = getBuiltIn$7; + var isCallable$l = isCallable$o; + var isPrototypeOf$2 = objectIsPrototypeOf; + var USE_SYMBOL_AS_UID = useSymbolAsUid; + + var $Object$3 = Object; + + var isSymbol$3 = USE_SYMBOL_AS_UID ? function (it) { + return typeof it == 'symbol'; + } : function (it) { + var $Symbol = getBuiltIn$6('Symbol'); + return isCallable$l($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it)); + }; + + var $String$3 = String; + + var tryToString$5 = function (argument) { + try { + return $String$3(argument); + } catch (error) { + return 'Object'; + } + }; + + var isCallable$k = isCallable$o; + var tryToString$4 = tryToString$5; + + var $TypeError$e = TypeError; + + // `Assert: IsCallable(argument) is true` + var aCallable$a = function (argument) { + if (isCallable$k(argument)) return argument; + throw new $TypeError$e(tryToString$4(argument) + ' is not a function'); + }; + + var aCallable$9 = aCallable$a; + var isNullOrUndefined$6 = isNullOrUndefined$8; + + // `GetMethod` abstract operation + // https://tc39.es/ecma262/#sec-getmethod + var getMethod$4 = function (V, P) { + var func = V[P]; + return isNullOrUndefined$6(func) ? undefined : aCallable$9(func); + }; + + var call$h = functionCall; + var isCallable$j = isCallable$o; + var isObject$g = isObject$j; + + var $TypeError$d = TypeError; + + // `OrdinaryToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-ordinarytoprimitive + var ordinaryToPrimitive$1 = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable$j(fn = input.toString) && !isObject$g(val = call$h(fn, input))) return val; + if (isCallable$j(fn = input.valueOf) && !isObject$g(val = call$h(fn, input))) return val; + if (pref !== 'string' && isCallable$j(fn = input.toString) && !isObject$g(val = call$h(fn, input))) return val; + throw new $TypeError$d("Can't convert object to primitive value"); + }; + + var call$g = functionCall; + var isObject$f = isObject$j; + var isSymbol$2 = isSymbol$3; + var getMethod$3 = getMethod$4; + var ordinaryToPrimitive = ordinaryToPrimitive$1; + var wellKnownSymbol$k = wellKnownSymbol$m; + + var $TypeError$c = TypeError; + var TO_PRIMITIVE = wellKnownSymbol$k('toPrimitive'); + + // `ToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-toprimitive + var toPrimitive$1 = function (input, pref) { + if (!isObject$f(input) || isSymbol$2(input)) return input; + var exoticToPrim = getMethod$3(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$g(exoticToPrim, input, pref); + if (!isObject$f(result) || isSymbol$2(result)) return result; + throw new $TypeError$c("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); + }; + + var toPrimitive = toPrimitive$1; + var isSymbol$1 = isSymbol$3; + + // `ToPropertyKey` abstract operation + // https://tc39.es/ecma262/#sec-topropertykey + var toPropertyKey$3 = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol$1(key) ? key : key + ''; + }; + + var DESCRIPTORS$b = descriptors; + var IE8_DOM_DEFINE$1 = ie8DomDefine; + var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug; + var anObject$e = anObject$f; + var toPropertyKey$2 = toPropertyKey$3; + + var $TypeError$b = TypeError; + // eslint-disable-next-line es/no-object-defineproperty -- safe + var $defineProperty = Object.defineProperty; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; + var ENUMERABLE = 'enumerable'; + var CONFIGURABLE$1 = 'configurable'; + var WRITABLE = 'writable'; + + // `Object.defineProperty` method + // https://tc39.es/ecma262/#sec-object.defineproperty + objectDefineProperty.f = DESCRIPTORS$b ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) { + anObject$e(O); + P = toPropertyKey$2(P); + anObject$e(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor$1(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); + } : $defineProperty : function defineProperty(O, P, Attributes) { + anObject$e(O); + P = toPropertyKey$2(P); + anObject$e(Attributes); + if (IE8_DOM_DEFINE$1) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$b('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; + }; + + var makeBuiltIn$3 = {exports: {}}; + + var DESCRIPTORS$a = descriptors; + var hasOwn$a = hasOwnProperty_1; + + var FunctionPrototype$2 = Function.prototype; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getDescriptor = DESCRIPTORS$a && Object.getOwnPropertyDescriptor; + + var EXISTS = hasOwn$a(FunctionPrototype$2, 'name'); + // additional protection from minified / mangled / dropped function names + var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something'; + var CONFIGURABLE = EXISTS && (!DESCRIPTORS$a || (DESCRIPTORS$a && getDescriptor(FunctionPrototype$2, 'name').configurable)); + + var functionName = { + EXISTS: EXISTS, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE + }; + + var uncurryThis$r = functionUncurryThis; + var isCallable$i = isCallable$o; + var store$1 = sharedStore; + + var functionToString$1 = uncurryThis$r(Function.toString); + + // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper + if (!isCallable$i(store$1.inspectSource)) { + store$1.inspectSource = function (it) { + return functionToString$1(it); + }; + } + + var inspectSource$3 = store$1.inspectSource; + + var global$f = global$n; + var isCallable$h = isCallable$o; + + var WeakMap$3 = global$f.WeakMap; + + var weakMapBasicDetection = isCallable$h(WeakMap$3) && /native code/.test(String(WeakMap$3)); + + var createPropertyDescriptor$4 = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; + }; + + var DESCRIPTORS$9 = descriptors; + var definePropertyModule$4 = objectDefineProperty; + var createPropertyDescriptor$3 = createPropertyDescriptor$4; + + var createNonEnumerableProperty$6 = DESCRIPTORS$9 ? function (object, key, value) { + return definePropertyModule$4.f(object, key, createPropertyDescriptor$3(1, value)); + } : function (object, key, value) { + object[key] = value; + return object; + }; + + var shared$2 = sharedExports; + var uid$1 = uid$3; + + var keys$1 = shared$2('keys'); + + var sharedKey$3 = function (key) { + return keys$1[key] || (keys$1[key] = uid$1(key)); + }; + + var hiddenKeys$5 = {}; + + var NATIVE_WEAK_MAP = weakMapBasicDetection; + var global$e = global$n; + var isObject$e = isObject$j; + var createNonEnumerableProperty$5 = createNonEnumerableProperty$6; + var hasOwn$9 = hasOwnProperty_1; + var shared$1 = sharedStore; + var sharedKey$2 = sharedKey$3; + var hiddenKeys$4 = hiddenKeys$5; + + var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; + var TypeError$2 = global$e.TypeError; + var WeakMap$2 = global$e.WeakMap; + var set$2, get$1, has$1; + + var enforce = function (it) { + return has$1(it) ? get$1(it) : set$2(it, {}); + }; + + var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject$e(it) || (state = get$1(it)).type !== TYPE) { + throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; + }; + + if (NATIVE_WEAK_MAP || shared$1.state) { + var store = shared$1.state || (shared$1.state = new WeakMap$2()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set$2 = function (it, metadata) { + if (store.has(it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get$1 = function (it) { + return store.get(it) || {}; + }; + has$1 = function (it) { + return store.has(it); + }; + } else { + var STATE = sharedKey$2('state'); + hiddenKeys$4[STATE] = true; + set$2 = function (it, metadata) { + if (hasOwn$9(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty$5(it, STATE, metadata); + return metadata; + }; + get$1 = function (it) { + return hasOwn$9(it, STATE) ? it[STATE] : {}; + }; + has$1 = function (it) { + return hasOwn$9(it, STATE); + }; + } + + var internalState = { + set: set$2, + get: get$1, + has: has$1, + enforce: enforce, + getterFor: getterFor + }; + + var uncurryThis$q = functionUncurryThis; + var fails$o = fails$u; + var isCallable$g = isCallable$o; + var hasOwn$8 = hasOwnProperty_1; + var DESCRIPTORS$8 = descriptors; + var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE; + var inspectSource$2 = inspectSource$3; + var InternalStateModule$5 = internalState; + + var enforceInternalState = InternalStateModule$5.enforce; + var getInternalState$3 = InternalStateModule$5.get; + var $String$2 = String; + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$8 = Object.defineProperty; + var stringSlice$6 = uncurryThis$q(''.slice); + var replace$3 = uncurryThis$q(''.replace); + var join = uncurryThis$q([].join); + + var CONFIGURABLE_LENGTH = DESCRIPTORS$8 && !fails$o(function () { + return defineProperty$8(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; + }); + + var TEMPLATE = String(String).split('String'); + + var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) { + if (stringSlice$6($String$2(name), 0, 7) === 'Symbol(') { + name = '[' + replace$3($String$2(name), /^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn$8(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) { + if (DESCRIPTORS$8) defineProperty$8(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn$8(options, 'arity') && value.length !== options.arity) { + defineProperty$8(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn$8(options, 'constructor') && options.constructor) { + if (DESCRIPTORS$8) defineProperty$8(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn$8(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; + }; + + // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative + // eslint-disable-next-line no-extend-native -- required + Function.prototype.toString = makeBuiltIn$2(function toString() { + return isCallable$g(this) && getInternalState$3(this).source || inspectSource$2(this); + }, 'toString'); + + var makeBuiltInExports = makeBuiltIn$3.exports; + + var isCallable$f = isCallable$o; + var definePropertyModule$3 = objectDefineProperty; + var makeBuiltIn$1 = makeBuiltInExports; + var defineGlobalProperty$1 = defineGlobalProperty$3; + + var defineBuiltIn$9 = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable$f(value)) makeBuiltIn$1(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty$1(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule$3.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; + }; + + var uncurryThis$p = functionUncurryThis; + + var toString$b = uncurryThis$p({}.toString); + var stringSlice$5 = uncurryThis$p(''.slice); + + var classofRaw$2 = function (it) { + return stringSlice$5(toString$b(it), 8, -1); + }; + + var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; + var isCallable$e = isCallable$o; + var classofRaw$1 = classofRaw$2; + var wellKnownSymbol$j = wellKnownSymbol$m; + + var TO_STRING_TAG$1 = wellKnownSymbol$j('toStringTag'); + var $Object$2 = Object; + + // ES3 wrong here + var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments'; + + // fallback for IE11 Script Access Denied error + var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } + }; + + // getting tag from ES6+ `Object.prototype.toString` + var classof$b = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object$2(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw$1(O) + // ES3 arguments fallback + : (result = classofRaw$1(O)) === 'Object' && isCallable$e(O.callee) ? 'Arguments' : result; + }; + + var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; + var classof$a = classof$b; + + // `Object.prototype.toString` method implementation + // https://tc39.es/ecma262/#sec-object.prototype.tostring + var objectToString$2 = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$a(this) + ']'; + }; + + var TO_STRING_TAG_SUPPORT = toStringTagSupport; + var defineBuiltIn$8 = defineBuiltIn$9; + var toString$a = objectToString$2; + + // `Object.prototype.toString` method + // https://tc39.es/ecma262/#sec-object.prototype.tostring + if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn$8(Object.prototype, 'toString', toString$a, { unsafe: true }); + } + + var objectGetOwnPropertyDescriptor = {}; + + var objectPropertyIsEnumerable = {}; + + var $propertyIsEnumerable$1 = {}.propertyIsEnumerable; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getOwnPropertyDescriptor$3 = Object.getOwnPropertyDescriptor; + + // Nashorn ~ JDK8 bug + var NASHORN_BUG = getOwnPropertyDescriptor$3 && !$propertyIsEnumerable$1.call({ 1: 2 }, 1); + + // `Object.prototype.propertyIsEnumerable` method implementation + // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable + objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor$3(this, V); + return !!descriptor && descriptor.enumerable; + } : $propertyIsEnumerable$1; + + var uncurryThis$o = functionUncurryThis; + var fails$n = fails$u; + var classof$9 = classofRaw$2; + + var $Object$1 = Object; + var split = uncurryThis$o(''.split); + + // fallback for non-array-like ES3 and non-enumerable old V8 strings + var indexedObject = fails$n(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object$1('z').propertyIsEnumerable(0); + }) ? function (it) { + return classof$9(it) === 'String' ? split(it, '') : $Object$1(it); + } : $Object$1; + + // toObject with fallback for non-array-like ES3 strings + var IndexedObject$3 = indexedObject; + var requireObjectCoercible$5 = requireObjectCoercible$7; + + var toIndexedObject$9 = function (it) { + return IndexedObject$3(requireObjectCoercible$5(it)); + }; + + var DESCRIPTORS$7 = descriptors; + var call$f = functionCall; + var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; + var createPropertyDescriptor$2 = createPropertyDescriptor$4; + var toIndexedObject$8 = toIndexedObject$9; + var toPropertyKey$1 = toPropertyKey$3; + var hasOwn$7 = hasOwnProperty_1; + var IE8_DOM_DEFINE = ie8DomDefine; + + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + + // `Object.getOwnPropertyDescriptor` method + // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor + objectGetOwnPropertyDescriptor.f = DESCRIPTORS$7 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$8(O); + P = toPropertyKey$1(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn$7(O, P)) return createPropertyDescriptor$2(!call$f(propertyIsEnumerableModule$1.f, O, P), O[P]); + }; + + var objectGetOwnPropertyNames = {}; + + var ceil = Math.ceil; + var floor$2 = Math.floor; + + // `Math.trunc` method + // https://tc39.es/ecma262/#sec-math.trunc + // eslint-disable-next-line es/no-math-trunc -- safe + var mathTrunc = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor$2 : ceil)(n); + }; + + var trunc = mathTrunc; + + // `ToIntegerOrInfinity` abstract operation + // https://tc39.es/ecma262/#sec-tointegerorinfinity + var toIntegerOrInfinity$4 = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); + }; + + var toIntegerOrInfinity$3 = toIntegerOrInfinity$4; + + var max$3 = Math.max; + var min$3 = Math.min; + + // Helper for a popular repeating case of the spec: + // Let integer be ? ToInteger(index). + // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). + var toAbsoluteIndex$4 = function (index, length) { + var integer = toIntegerOrInfinity$3(index); + return integer < 0 ? max$3(integer + length, 0) : min$3(integer, length); + }; + + var toIntegerOrInfinity$2 = toIntegerOrInfinity$4; + + var min$2 = Math.min; + + // `ToLength` abstract operation + // https://tc39.es/ecma262/#sec-tolength + var toLength$3 = function (argument) { + return argument > 0 ? min$2(toIntegerOrInfinity$2(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 + }; + + var toLength$2 = toLength$3; + + // `LengthOfArrayLike` abstract operation + // https://tc39.es/ecma262/#sec-lengthofarraylike + var lengthOfArrayLike$9 = function (obj) { + return toLength$2(obj.length); + }; + + var toIndexedObject$7 = toIndexedObject$9; + var toAbsoluteIndex$3 = toAbsoluteIndex$4; + var lengthOfArrayLike$8 = lengthOfArrayLike$9; + + // `Array.prototype.{ indexOf, includes }` methods implementation + var createMethod$4 = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject$7($this); + var length = lengthOfArrayLike$8(O); + var index = toAbsoluteIndex$3(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; + }; + + var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod$4(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod$4(false) + }; + + var uncurryThis$n = functionUncurryThis; + var hasOwn$6 = hasOwnProperty_1; + var toIndexedObject$6 = toIndexedObject$9; + var indexOf$1 = arrayIncludes.indexOf; + var hiddenKeys$3 = hiddenKeys$5; + + var push$4 = uncurryThis$n([].push); + + var objectKeysInternal = function (object, names) { + var O = toIndexedObject$6(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn$6(hiddenKeys$3, key) && hasOwn$6(O, key) && push$4(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn$6(O, key = names[i++])) { + ~indexOf$1(result, key) || push$4(result, key); + } + return result; + }; + + // IE8- don't enum bug keys + var enumBugKeys$3 = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' + ]; + + var internalObjectKeys$1 = objectKeysInternal; + var enumBugKeys$2 = enumBugKeys$3; + + var hiddenKeys$2 = enumBugKeys$2.concat('length', 'prototype'); + + // `Object.getOwnPropertyNames` method + // https://tc39.es/ecma262/#sec-object.getownpropertynames + // eslint-disable-next-line es/no-object-getownpropertynames -- safe + objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys$2); + }; + + var objectGetOwnPropertySymbols = {}; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe + objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; + + var getBuiltIn$5 = getBuiltIn$7; + var uncurryThis$m = functionUncurryThis; + var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames; + var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; + var anObject$d = anObject$f; + + var concat$2 = uncurryThis$m([].concat); + + // all object keys, includes non-enumerable and symbols + var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule$1.f(anObject$d(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f; + return getOwnPropertySymbols ? concat$2(keys, getOwnPropertySymbols(it)) : keys; + }; + + var hasOwn$5 = hasOwnProperty_1; + var ownKeys = ownKeys$1; + var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; + var definePropertyModule$2 = objectDefineProperty; + + var copyConstructorProperties$1 = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule$2.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn$5(target, key) && !(exceptions && hasOwn$5(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } + }; + + var fails$m = fails$u; + var isCallable$d = isCallable$o; + + var replacement = /#|\.prototype\./; + + var isForced$3 = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable$d(detection) ? fails$m(detection) + : !!detection; + }; + + var normalize = isForced$3.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); + }; + + var data = isForced$3.data = {}; + var NATIVE = isForced$3.NATIVE = 'N'; + var POLYFILL = isForced$3.POLYFILL = 'P'; + + var isForced_1 = isForced$3; + + var global$d = global$n; + var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f; + var createNonEnumerableProperty$4 = createNonEnumerableProperty$6; + var defineBuiltIn$7 = defineBuiltIn$9; + var defineGlobalProperty = defineGlobalProperty$3; + var copyConstructorProperties = copyConstructorProperties$1; + var isForced$2 = isForced_1; + + /* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key + */ + var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global$d; + } else if (STATIC) { + target = global$d[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = (global$d[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor$2(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced$2(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty$4(sourceProperty, 'sham', true); + } + defineBuiltIn$7(target, key, sourceProperty, options); + } + }; + + var global$c = global$n; + var classof$8 = classofRaw$2; + + var engineIsNode = classof$8(global$c.process) === 'process'; + + var uncurryThis$l = functionUncurryThis; + var aCallable$8 = aCallable$a; + + var functionUncurryThisAccessor = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis$l(aCallable$8(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } + }; + + var isCallable$c = isCallable$o; + + var $String$1 = String; + var $TypeError$a = TypeError; + + var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$c(argument)) return argument; + throw new $TypeError$a("Can't set " + $String$1(argument) + ' as a prototype'); + }; + + /* eslint-disable no-proto -- safe */ + var uncurryThisAccessor = functionUncurryThisAccessor; + var anObject$c = anObject$f; + var aPossiblePrototype = aPossiblePrototype$1; + + // `Object.setPrototypeOf` method + // https://tc39.es/ecma262/#sec-object.setprototypeof + // Works with __proto__ only. Old v8 can't work with null proto objects. + // eslint-disable-next-line es/no-object-setprototypeof -- safe + var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject$c(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; + }() : undefined); + + var defineProperty$7 = objectDefineProperty.f; + var hasOwn$4 = hasOwnProperty_1; + var wellKnownSymbol$i = wellKnownSymbol$m; + + var TO_STRING_TAG = wellKnownSymbol$i('toStringTag'); + + var setToStringTag$5 = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$4(target, TO_STRING_TAG)) { + defineProperty$7(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } + }; + + var makeBuiltIn = makeBuiltInExports; + var defineProperty$6 = objectDefineProperty; + + var defineBuiltInAccessor$3 = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true }); + return defineProperty$6.f(target, name, descriptor); + }; + + var getBuiltIn$4 = getBuiltIn$7; + var defineBuiltInAccessor$2 = defineBuiltInAccessor$3; + var wellKnownSymbol$h = wellKnownSymbol$m; + var DESCRIPTORS$6 = descriptors; + + var SPECIES$6 = wellKnownSymbol$h('species'); + + var setSpecies$2 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME); + + if (DESCRIPTORS$6 && Constructor && !Constructor[SPECIES$6]) { + defineBuiltInAccessor$2(Constructor, SPECIES$6, { + configurable: true, + get: function () { return this; } + }); + } + }; + + var isPrototypeOf$1 = objectIsPrototypeOf; + + var $TypeError$9 = TypeError; + + var anInstance$4 = function (it, Prototype) { + if (isPrototypeOf$1(Prototype, it)) return it; + throw new $TypeError$9('Incorrect invocation'); + }; + + var uncurryThis$k = functionUncurryThis; + var fails$l = fails$u; + var isCallable$b = isCallable$o; + var classof$7 = classof$b; + var getBuiltIn$3 = getBuiltIn$7; + var inspectSource$1 = inspectSource$3; + + var noop = function () { /* empty */ }; + var empty = []; + var construct = getBuiltIn$3('Reflect', 'construct'); + var constructorRegExp = /^\s*(?:class|function)\b/; + var exec$1 = uncurryThis$k(constructorRegExp.exec); + var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + + var isConstructorModern = function isConstructor(argument) { + if (!isCallable$b(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } + }; + + var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$b(argument)) return false; + switch (classof$7(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec$1(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } + }; + + isConstructorLegacy.sham = true; + + // `IsConstructor` abstract operation + // https://tc39.es/ecma262/#sec-isconstructor + var isConstructor$4 = !construct || fails$l(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; + }) ? isConstructorLegacy : isConstructorModern; + + var isConstructor$3 = isConstructor$4; + var tryToString$3 = tryToString$5; + + var $TypeError$8 = TypeError; + + // `Assert: IsConstructor(argument) is true` + var aConstructor$1 = function (argument) { + if (isConstructor$3(argument)) return argument; + throw new $TypeError$8(tryToString$3(argument) + ' is not a constructor'); + }; + + var anObject$b = anObject$f; + var aConstructor = aConstructor$1; + var isNullOrUndefined$5 = isNullOrUndefined$8; + var wellKnownSymbol$g = wellKnownSymbol$m; + + var SPECIES$5 = wellKnownSymbol$g('species'); + + // `SpeciesConstructor` abstract operation + // https://tc39.es/ecma262/#sec-speciesconstructor + var speciesConstructor$1 = function (O, defaultConstructor) { + var C = anObject$b(O).constructor; + var S; + return C === undefined || isNullOrUndefined$5(S = anObject$b(C)[SPECIES$5]) ? defaultConstructor : aConstructor(S); + }; + + var NATIVE_BIND$1 = functionBindNative; + + var FunctionPrototype$1 = Function.prototype; + var apply$3 = FunctionPrototype$1.apply; + var call$e = FunctionPrototype$1.call; + + // eslint-disable-next-line es/no-reflect -- safe + var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$e.bind(apply$3) : function () { + return call$e.apply(apply$3, arguments); + }); + + var classofRaw = classofRaw$2; + var uncurryThis$j = functionUncurryThis; + + var functionUncurryThisClause = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis$j(fn); + }; + + var uncurryThis$i = functionUncurryThisClause; + var aCallable$7 = aCallable$a; + var NATIVE_BIND = functionBindNative; + + var bind$7 = uncurryThis$i(uncurryThis$i.bind); + + // optional / simple context binding + var functionBindContext = function (fn, that) { + aCallable$7(fn); + return that === undefined ? fn : NATIVE_BIND ? bind$7(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; + }; + + var getBuiltIn$2 = getBuiltIn$7; + + var html$2 = getBuiltIn$2('document', 'documentElement'); + + var uncurryThis$h = functionUncurryThis; + + var arraySlice$3 = uncurryThis$h([].slice); + + var $TypeError$7 = TypeError; + + var validateArgumentsLength$1 = function (passed, required) { + if (passed < required) throw new $TypeError$7('Not enough arguments'); + return passed; + }; + + var userAgent$4 = engineUserAgent; + + // eslint-disable-next-line redos/no-vulnerable -- safe + var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$4); + + var global$b = global$n; + var apply$2 = functionApply; + var bind$6 = functionBindContext; + var isCallable$a = isCallable$o; + var hasOwn$3 = hasOwnProperty_1; + var fails$k = fails$u; + var html$1 = html$2; + var arraySlice$2 = arraySlice$3; + var createElement = documentCreateElement$2; + var validateArgumentsLength = validateArgumentsLength$1; + var IS_IOS$1 = engineIsIos; + var IS_NODE$3 = engineIsNode; + + var set$1 = global$b.setImmediate; + var clear = global$b.clearImmediate; + var process$2 = global$b.process; + var Dispatch = global$b.Dispatch; + var Function$1 = global$b.Function; + var MessageChannel = global$b.MessageChannel; + var String$1 = global$b.String; + var counter = 0; + var queue$2 = {}; + var ONREADYSTATECHANGE = 'onreadystatechange'; + var $location, defer, channel, port; + + fails$k(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = global$b.location; + }); + + var run = function (id) { + if (hasOwn$3(queue$2, id)) { + var fn = queue$2[id]; + delete queue$2[id]; + fn(); + } + }; + + var runner = function (id) { + return function () { + run(id); + }; + }; + + var eventListener = function (event) { + run(event.data); + }; + + var globalPostMessageDefer = function (id) { + // old engines have not location.origin + global$b.postMessage(String$1(id), $location.protocol + '//' + $location.host); + }; + + // Node.js 0.9+ & IE10+ has setImmediate, otherwise: + if (!set$1 || !clear) { + set$1 = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable$a(handler) ? handler : Function$1(handler); + var args = arraySlice$2(arguments, 1); + queue$2[++counter] = function () { + apply$2(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue$2[id]; + }; + // Node.js 0.8- + if (IS_NODE$3) { + defer = function (id) { + process$2.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS$1) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind$6(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global$b.addEventListener && + isCallable$a(global$b.postMessage) && + !global$b.importScripts && + $location && $location.protocol !== 'file:' && + !fails$k(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + global$b.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html$1.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } + } + + var task$1 = { + set: set$1, + clear: clear + }; + + var Queue$2 = function () { + this.head = null; + this.tail = null; + }; + + Queue$2.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } + }; + + var queue$1 = Queue$2; + + var userAgent$3 = engineUserAgent; + + var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$3) && typeof Pebble != 'undefined'; + + var userAgent$2 = engineUserAgent; + + var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent$2); + + var global$a = global$n; + var bind$5 = functionBindContext; + var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; + var macrotask = task$1.set; + var Queue$1 = queue$1; + var IS_IOS = engineIsIos; + var IS_IOS_PEBBLE = engineIsIosPebble; + var IS_WEBOS_WEBKIT = engineIsWebosWebkit; + var IS_NODE$2 = engineIsNode; + + var MutationObserver = global$a.MutationObserver || global$a.WebKitMutationObserver; + var document$2 = global$a.document; + var process$1 = global$a.process; + var Promise$3 = global$a.Promise; + // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` + var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$a, 'queueMicrotask'); + var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; + var notify$1, toggle, node, promise, then; + + // modern engines have queueMicrotask method + if (!microtask$1) { + var queue = new Queue$1(); + + var flush = function () { + var parent, fn; + if (IS_NODE$2 && (parent = process$1.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify$1(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { + toggle = true; + node = document$2.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify$1 = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise$3 && Promise$3.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise$3.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise$3; + then = bind$5(promise.then, promise); + notify$1 = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE$2) { + notify$1 = function () { + process$1.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind$5(macrotask, global$a); + notify$1 = function () { + macrotask(flush); + }; + } + + microtask$1 = function (fn) { + if (!queue.head) notify$1(); + queue.add(fn); + }; + } + + var microtask_1 = microtask$1; + + var hostReportErrors$1 = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } + }; + + var perform$4 = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } + }; + + var global$9 = global$n; + + var promiseNativeConstructor = global$9.Promise; + + /* global Deno -- Deno case */ + var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object'; + + var IS_DENO$1 = engineIsDeno; + var IS_NODE$1 = engineIsNode; + + var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 + && typeof window == 'object' + && typeof document == 'object'; + + var global$8 = global$n; + var NativePromiseConstructor$3 = promiseNativeConstructor; + var isCallable$9 = isCallable$o; + var isForced$1 = isForced_1; + var inspectSource = inspectSource$3; + var wellKnownSymbol$f = wellKnownSymbol$m; + var IS_BROWSER = engineIsBrowser; + var IS_DENO = engineIsDeno; + var V8_VERSION$2 = engineV8Version; + + NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype; + var SPECIES$4 = wellKnownSymbol$f('species'); + var SUBCLASSING = false; + var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$9(global$8.PromiseRejectionEvent); + + var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION$2 === 66) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION$2 || V8_VERSION$2 < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES$4] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1; + }); + + var promiseConstructorDetection = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1, + SUBCLASSING: SUBCLASSING + }; + + var newPromiseCapability$2 = {}; + + var aCallable$6 = aCallable$a; + + var $TypeError$6 = TypeError; + + var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError$6('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable$6(resolve); + this.reject = aCallable$6(reject); + }; + + // `NewPromiseCapability` abstract operation + // https://tc39.es/ecma262/#sec-newpromisecapability + newPromiseCapability$2.f = function (C) { + return new PromiseCapability(C); + }; + + var $$p = _export; + var IS_NODE = engineIsNode; + var global$7 = global$n; + var call$d = functionCall; + var defineBuiltIn$6 = defineBuiltIn$9; + var setPrototypeOf$2 = objectSetPrototypeOf; + var setToStringTag$4 = setToStringTag$5; + var setSpecies$1 = setSpecies$2; + var aCallable$5 = aCallable$a; + var isCallable$8 = isCallable$o; + var isObject$d = isObject$j; + var anInstance$3 = anInstance$4; + var speciesConstructor = speciesConstructor$1; + var task = task$1.set; + var microtask = microtask_1; + var hostReportErrors = hostReportErrors$1; + var perform$3 = perform$4; + var Queue = queue$1; + var InternalStateModule$4 = internalState; + var NativePromiseConstructor$2 = promiseNativeConstructor; + var PromiseConstructorDetection = promiseConstructorDetection; + var newPromiseCapabilityModule$4 = newPromiseCapability$2; + + var PROMISE = 'Promise'; + var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR; + var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; + var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; + var getInternalPromiseState = InternalStateModule$4.getterFor(PROMISE); + var setInternalState$4 = InternalStateModule$4.set; + var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype; + var PromiseConstructor = NativePromiseConstructor$2; + var PromisePrototype = NativePromisePrototype$1; + var TypeError$1 = global$7.TypeError; + var document$1 = global$7.document; + var process = global$7.process; + var newPromiseCapability$1 = newPromiseCapabilityModule$4.f; + var newGenericPromiseCapability = newPromiseCapability$1; + + var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$7.dispatchEvent); + var UNHANDLED_REJECTION = 'unhandledrejection'; + var REJECTION_HANDLED = 'rejectionhandled'; + var PENDING = 0; + var FULFILLED = 1; + var REJECTED = 2; + var HANDLED = 1; + var UNHANDLED = 2; + + var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + + // helpers + var isThenable = function (it) { + var then; + return isObject$d(it) && isCallable$8(then = it.then) ? then : false; + }; + + var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$d(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } + }; + + var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); + }; + + var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$1.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global$7.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$7['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); + }; + + var onUnhandled = function (state) { + call$d(task, global$7, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform$3(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); + }; + + var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; + }; + + var onHandleUnhandled = function (state) { + call$d(task, global$7, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); + }; + + var bind$4 = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; + }; + + var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); + }; + + var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call$d(then, value, + bind$4(internalResolve, wrapper, state), + bind$4(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } + }; + + // constructor polyfill + if (FORCED_PROMISE_CONSTRUCTOR$4) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance$3(this, PromisePrototype); + aCallable$5(executor); + call$d(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind$4(internalResolve, state), bind$4(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState$4(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: undefined + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn$6(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable$8(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$8(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind$4(internalResolve, state); + this.reject = bind$4(internalReject, state); + }; + + newPromiseCapabilityModule$4.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (isCallable$8(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) { + nativeThen = NativePromisePrototype$1.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn$6(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call$d(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype$1.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf$2) { + setPrototypeOf$2(NativePromisePrototype$1, PromisePrototype); + } + } + } + + $$p({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, { + Promise: PromiseConstructor + }); + + setToStringTag$4(PromiseConstructor, PROMISE, false); + setSpecies$1(PROMISE); + + var iterators = {}; + + var wellKnownSymbol$e = wellKnownSymbol$m; + var Iterators$4 = iterators; + + var ITERATOR$5 = wellKnownSymbol$e('iterator'); + var ArrayPrototype$1 = Array.prototype; + + // check on default Array iterator + var isArrayIteratorMethod$2 = function (it) { + return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$5] === it); + }; + + var classof$6 = classof$b; + var getMethod$2 = getMethod$4; + var isNullOrUndefined$4 = isNullOrUndefined$8; + var Iterators$3 = iterators; + var wellKnownSymbol$d = wellKnownSymbol$m; + + var ITERATOR$4 = wellKnownSymbol$d('iterator'); + + var getIteratorMethod$3 = function (it) { + if (!isNullOrUndefined$4(it)) return getMethod$2(it, ITERATOR$4) + || getMethod$2(it, '@@iterator') + || Iterators$3[classof$6(it)]; + }; + + var call$c = functionCall; + var aCallable$4 = aCallable$a; + var anObject$a = anObject$f; + var tryToString$2 = tryToString$5; + var getIteratorMethod$2 = getIteratorMethod$3; + + var $TypeError$5 = TypeError; + + var getIterator$2 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$2(argument) : usingIterator; + if (aCallable$4(iteratorMethod)) return anObject$a(call$c(iteratorMethod, argument)); + throw new $TypeError$5(tryToString$2(argument) + ' is not iterable'); + }; + + var call$b = functionCall; + var anObject$9 = anObject$f; + var getMethod$1 = getMethod$4; + + var iteratorClose$2 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$9(iterator); + try { + innerResult = getMethod$1(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$b(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$9(innerResult); + return value; + }; + + var bind$3 = functionBindContext; + var call$a = functionCall; + var anObject$8 = anObject$f; + var tryToString$1 = tryToString$5; + var isArrayIteratorMethod$1 = isArrayIteratorMethod$2; + var lengthOfArrayLike$7 = lengthOfArrayLike$9; + var isPrototypeOf = objectIsPrototypeOf; + var getIterator$1 = getIterator$2; + var getIteratorMethod$1 = getIteratorMethod$3; + var iteratorClose$1 = iteratorClose$2; + + var $TypeError$4 = TypeError; + + var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; + }; + + var ResultPrototype = Result.prototype; + + var iterate$6 = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind$3(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose$1(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject$8(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod$1(iterable); + if (!iterFn) throw new $TypeError$4(tryToString$1(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod$1(iterFn)) { + for (index = 0, length = lengthOfArrayLike$7(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator$1(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call$a(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose$1(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + }; + + var wellKnownSymbol$c = wellKnownSymbol$m; + + var ITERATOR$3 = wellKnownSymbol$c('iterator'); + var SAFE_CLOSING = false; + + try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR$3] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); + } catch (error) { /* empty */ } + + var checkCorrectnessOfIteration$3 = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR$3] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; + }; + + var NativePromiseConstructor$1 = promiseNativeConstructor; + var checkCorrectnessOfIteration$2 = checkCorrectnessOfIteration$3; + var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR; + + var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration$2(function (iterable) { + NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ }); + }); + + var $$o = _export; + var call$9 = functionCall; + var aCallable$3 = aCallable$a; + var newPromiseCapabilityModule$3 = newPromiseCapability$2; + var perform$2 = perform$4; + var iterate$5 = iterate$6; + var PROMISE_STATICS_INCORRECT_ITERATION$2 = promiseStaticsIncorrectIteration; + + // `Promise.all` method + // https://tc39.es/ecma262/#sec-promise.all + $$o({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$2 }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$3.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform$2(function () { + var $promiseResolve = aCallable$3(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$5(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$9($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var $$n = _export; + var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR; + var NativePromiseConstructor = promiseNativeConstructor; + var getBuiltIn$1 = getBuiltIn$7; + var isCallable$7 = isCallable$o; + var defineBuiltIn$5 = defineBuiltIn$9; + + var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + + // `Promise.prototype.catch` method + // https://tc39.es/ecma262/#sec-promise.prototype.catch + $$n({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + + // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` + if (isCallable$7(NativePromiseConstructor)) { + var method = getBuiltIn$1('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn$5(NativePromisePrototype, 'catch', method, { unsafe: true }); + } + } + + var $$m = _export; + var call$8 = functionCall; + var aCallable$2 = aCallable$a; + var newPromiseCapabilityModule$2 = newPromiseCapability$2; + var perform$1 = perform$4; + var iterate$4 = iterate$6; + var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration; + + // `Promise.race` method + // https://tc39.es/ecma262/#sec-promise.race + $$m({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$2.f(C); + var reject = capability.reject; + var result = perform$1(function () { + var $promiseResolve = aCallable$2(C.resolve); + iterate$4(iterable, function (promise) { + call$8($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var $$l = _export; + var call$7 = functionCall; + var newPromiseCapabilityModule$1 = newPromiseCapability$2; + var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR; + + // `Promise.reject` method + // https://tc39.es/ecma262/#sec-promise.reject + $$l({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule$1.f(this); + call$7(capability.reject, undefined, r); + return capability.promise; + } + }); + + var anObject$7 = anObject$f; + var isObject$c = isObject$j; + var newPromiseCapability = newPromiseCapability$2; + + var promiseResolve$1 = function (C, x) { + anObject$7(C); + if (isObject$c(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; + }; + + var $$k = _export; + var getBuiltIn = getBuiltIn$7; + var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR; + var promiseResolve = promiseResolve$1; + + getBuiltIn('Promise'); + + // `Promise.resolve` method + // https://tc39.es/ecma262/#sec-promise.resolve + $$k({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(this, x); + } + }); + + var objectDefineProperties = {}; + + var internalObjectKeys = objectKeysInternal; + var enumBugKeys$1 = enumBugKeys$3; + + // `Object.keys` method + // https://tc39.es/ecma262/#sec-object.keys + // eslint-disable-next-line es/no-object-keys -- safe + var objectKeys$3 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys$1); + }; + + var DESCRIPTORS$5 = descriptors; + var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; + var definePropertyModule$1 = objectDefineProperty; + var anObject$6 = anObject$f; + var toIndexedObject$5 = toIndexedObject$9; + var objectKeys$2 = objectKeys$3; + + // `Object.defineProperties` method + // https://tc39.es/ecma262/#sec-object.defineproperties + // eslint-disable-next-line es/no-object-defineproperties -- safe + objectDefineProperties.f = DESCRIPTORS$5 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject$6(O); + var props = toIndexedObject$5(Properties); + var keys = objectKeys$2(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]); + return O; + }; + + /* global ActiveXObject -- old IE, WSH */ + var anObject$5 = anObject$f; + var definePropertiesModule = objectDefineProperties; + var enumBugKeys = enumBugKeys$3; + var hiddenKeys$1 = hiddenKeys$5; + var html = html$2; + var documentCreateElement$1 = documentCreateElement$2; + var sharedKey$1 = sharedKey$3; + + var GT = '>'; + var LT = '<'; + var PROTOTYPE = 'prototype'; + var SCRIPT = 'script'; + var IE_PROTO$1 = sharedKey$1('IE_PROTO'); + + var EmptyConstructor = function () { /* empty */ }; + + var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; + }; + + // Create object with fake `null` prototype: use ActiveX Object with cleared prototype + var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; + }; + + // Create object with fake `null` prototype: use iframe Object with cleared prototype + var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement$1('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; + }; + + // Check for document.domain and active x support + // No need to use active x approach when document.domain is not set + // see https://github.com/es-shims/es5-shim/issues/150 + // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 + // avoid IE GC bug + var activeXDocument; + var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); + }; + + hiddenKeys$1[IE_PROTO$1] = true; + + // `Object.create` method + // https://tc39.es/ecma262/#sec-object.create + // eslint-disable-next-line es/no-object-create -- safe + var objectCreate$1 = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject$5(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO$1] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : definePropertiesModule.f(result, Properties); + }; + + var wellKnownSymbol$b = wellKnownSymbol$m; + var create$3 = objectCreate$1; + var defineProperty$5 = objectDefineProperty.f; + + var UNSCOPABLES = wellKnownSymbol$b('unscopables'); + var ArrayPrototype = Array.prototype; + + // Array.prototype[@@unscopables] + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + if (ArrayPrototype[UNSCOPABLES] === undefined) { + defineProperty$5(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create$3(null) + }); + } + + // add a key to Array.prototype[@@unscopables] + var addToUnscopables$3 = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; + }; + + var fails$j = fails$u; + + var correctPrototypeGetter = !fails$j(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; + }); + + var hasOwn$2 = hasOwnProperty_1; + var isCallable$6 = isCallable$o; + var toObject$8 = toObject$a; + var sharedKey = sharedKey$3; + var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter; + + var IE_PROTO = sharedKey('IE_PROTO'); + var $Object = Object; + var ObjectPrototype = $Object.prototype; + + // `Object.getPrototypeOf` method + // https://tc39.es/ecma262/#sec-object.getprototypeof + // eslint-disable-next-line es/no-object-getprototypeof -- safe + var objectGetPrototypeOf$1 = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) { + var object = toObject$8(O); + if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable$6(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof $Object ? ObjectPrototype : null; + }; + + var fails$i = fails$u; + var isCallable$5 = isCallable$o; + var isObject$b = isObject$j; + var getPrototypeOf$1 = objectGetPrototypeOf$1; + var defineBuiltIn$4 = defineBuiltIn$9; + var wellKnownSymbol$a = wellKnownSymbol$m; + + var ITERATOR$2 = wellKnownSymbol$a('iterator'); + var BUGGY_SAFARI_ITERATORS$1 = false; + + // `%IteratorPrototype%` object + // https://tc39.es/ecma262/#sec-%iteratorprototype%-object + var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator; + + /* eslint-disable es/no-array-prototype-keys -- safe */ + if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype; + } + } + + var NEW_ITERATOR_PROTOTYPE = !isObject$b(IteratorPrototype$2) || fails$i(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype$2[ITERATOR$2].call(test) !== test; + }); + + if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {}; + + // `%IteratorPrototype%[@@iterator]()` method + // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator + if (!isCallable$5(IteratorPrototype$2[ITERATOR$2])) { + defineBuiltIn$4(IteratorPrototype$2, ITERATOR$2, function () { + return this; + }); + } + + var iteratorsCore = { + IteratorPrototype: IteratorPrototype$2, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1 + }; + + var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; + var create$2 = objectCreate$1; + var createPropertyDescriptor$1 = createPropertyDescriptor$4; + var setToStringTag$3 = setToStringTag$5; + var Iterators$2 = iterators; + + var returnThis$1 = function () { return this; }; + + var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create$2(IteratorPrototype$1, { next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next) }); + setToStringTag$3(IteratorConstructor, TO_STRING_TAG, false); + Iterators$2[TO_STRING_TAG] = returnThis$1; + return IteratorConstructor; + }; + + var $$j = _export; + var call$6 = functionCall; + var FunctionName = functionName; + var isCallable$4 = isCallable$o; + var createIteratorConstructor = iteratorCreateConstructor; + var getPrototypeOf = objectGetPrototypeOf$1; + var setPrototypeOf$1 = objectSetPrototypeOf; + var setToStringTag$2 = setToStringTag$5; + var createNonEnumerableProperty$3 = createNonEnumerableProperty$6; + var defineBuiltIn$3 = defineBuiltIn$9; + var wellKnownSymbol$9 = wellKnownSymbol$m; + var Iterators$1 = iterators; + var IteratorsCore = iteratorsCore; + + var PROPER_FUNCTION_NAME$1 = FunctionName.PROPER; + var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; + var IteratorPrototype = IteratorsCore.IteratorPrototype; + var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; + var ITERATOR$1 = wellKnownSymbol$9('iterator'); + var KEYS = 'keys'; + var VALUES = 'values'; + var ENTRIES = 'entries'; + + var returnThis = function () { return this; }; + + var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND]; + + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } + + return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR$1] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf$1) { + setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable$4(CurrentIteratorPrototype[ITERATOR$1])) { + defineBuiltIn$3(CurrentIteratorPrototype, ITERATOR$1, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag$2(CurrentIteratorPrototype, TO_STRING_TAG, true); + } + } + + // fix Array.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME$1 && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty$3(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call$6(nativeIterator, this); }; + } + } + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + defineBuiltIn$3(IterablePrototype, KEY, methods[KEY]); + } + } else $$j({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if (IterablePrototype[ITERATOR$1] !== defaultIterator) { + defineBuiltIn$3(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT }); + } + Iterators$1[NAME] = defaultIterator; + + return methods; + }; + + // `CreateIterResultObject` abstract operation + // https://tc39.es/ecma262/#sec-createiterresultobject + var createIterResultObject$3 = function (value, done) { + return { value: value, done: done }; + }; + + var toIndexedObject$4 = toIndexedObject$9; + var addToUnscopables$2 = addToUnscopables$3; + var Iterators = iterators; + var InternalStateModule$3 = internalState; + var defineProperty$4 = objectDefineProperty.f; + var defineIterator$2 = iteratorDefine; + var createIterResultObject$2 = createIterResultObject$3; + var DESCRIPTORS$4 = descriptors; + + var ARRAY_ITERATOR = 'Array Iterator'; + var setInternalState$3 = InternalStateModule$3.set; + var getInternalState$2 = InternalStateModule$3.getterFor(ARRAY_ITERATOR); + + // `Array.prototype.entries` method + // https://tc39.es/ecma262/#sec-array.prototype.entries + // `Array.prototype.keys` method + // https://tc39.es/ecma262/#sec-array.prototype.keys + // `Array.prototype.values` method + // https://tc39.es/ecma262/#sec-array.prototype.values + // `Array.prototype[@@iterator]` method + // https://tc39.es/ecma262/#sec-array.prototype-@@iterator + // `CreateArrayIterator` internal method + // https://tc39.es/ecma262/#sec-createarrayiterator + var es_array_iterator = defineIterator$2(Array, 'Array', function (iterated, kind) { + setInternalState$3(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject$4(iterated), // target + index: 0, // next index + kind: kind // kind + }); + // `%ArrayIteratorPrototype%.next` method + // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next + }, function () { + var state = getInternalState$2(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return createIterResultObject$2(undefined, true); + } + switch (state.kind) { + case 'keys': return createIterResultObject$2(index, false); + case 'values': return createIterResultObject$2(target[index], false); + } return createIterResultObject$2([index, target[index]], false); + }, 'values'); + + // argumentsList[@@iterator] is %ArrayProto_values% + // https://tc39.es/ecma262/#sec-createunmappedargumentsobject + // https://tc39.es/ecma262/#sec-createmappedargumentsobject + var values = Iterators.Arguments = Iterators.Array; + + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + addToUnscopables$2('keys'); + addToUnscopables$2('values'); + addToUnscopables$2('entries'); + + // V8 ~ Chrome 45- bug + if (DESCRIPTORS$4 && values.name !== 'values') try { + defineProperty$4(values, 'name', { value: 'values' }); + } catch (error) { /* empty */ } + + var $$i = _export; + var call$5 = functionCall; + var aCallable$1 = aCallable$a; + var newPromiseCapabilityModule = newPromiseCapability$2; + var perform = perform$4; + var iterate$3 = iterate$6; + var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration; + + // `Promise.allSettled` method + // https://tc39.es/ecma262/#sec-promise.allsettled + $$i({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + allSettled: function allSettled(iterable) { + var C = this; + var capability = newPromiseCapabilityModule.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aCallable$1(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$3(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$5(promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'fulfilled', value: value }; + --remaining || resolve(values); + }, function (error) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'rejected', reason: error }; + --remaining || resolve(values); + }); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var classof$5 = classof$b; + + var $String = String; + + var toString$9 = function (argument) { + if (classof$5(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string'); + return $String(argument); + }; + + var uncurryThis$g = functionUncurryThis; + var toIntegerOrInfinity$1 = toIntegerOrInfinity$4; + var toString$8 = toString$9; + var requireObjectCoercible$4 = requireObjectCoercible$7; + + var charAt$4 = uncurryThis$g(''.charAt); + var charCodeAt = uncurryThis$g(''.charCodeAt); + var stringSlice$4 = uncurryThis$g(''.slice); + + var createMethod$3 = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = toString$8(requireObjectCoercible$4($this)); + var position = toIntegerOrInfinity$1(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = charCodeAt(S, position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt$4(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice$4(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; + }; + + var stringMultibyte = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod$3(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod$3(true) + }; + + var charAt$3 = stringMultibyte.charAt; + var toString$7 = toString$9; + var InternalStateModule$2 = internalState; + var defineIterator$1 = iteratorDefine; + var createIterResultObject$1 = createIterResultObject$3; + + var STRING_ITERATOR = 'String Iterator'; + var setInternalState$2 = InternalStateModule$2.set; + var getInternalState$1 = InternalStateModule$2.getterFor(STRING_ITERATOR); + + // `String.prototype[@@iterator]` method + // https://tc39.es/ecma262/#sec-string.prototype-@@iterator + defineIterator$1(String, 'String', function (iterated) { + setInternalState$2(this, { + type: STRING_ITERATOR, + string: toString$7(iterated), + index: 0 + }); + // `%StringIteratorPrototype%.next` method + // https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next + }, function next() { + var state = getInternalState$1(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return createIterResultObject$1(undefined, true); + point = charAt$3(string, index); + state.index += point.length; + return createIterResultObject$1(point, false); + }); + + // iterable DOM collections + // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods + var domIterables = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 + }; + + // in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList` + var documentCreateElement = documentCreateElement$2; + + var classList = documentCreateElement('span').classList; + var DOMTokenListPrototype$2 = classList && classList.constructor && classList.constructor.prototype; + + var domTokenListPrototype = DOMTokenListPrototype$2 === Object.prototype ? undefined : DOMTokenListPrototype$2; + + var global$6 = global$n; + var DOMIterables$1 = domIterables; + var DOMTokenListPrototype$1 = domTokenListPrototype; + var ArrayIteratorMethods = es_array_iterator; + var createNonEnumerableProperty$2 = createNonEnumerableProperty$6; + var setToStringTag$1 = setToStringTag$5; + var wellKnownSymbol$8 = wellKnownSymbol$m; + + var ITERATOR = wellKnownSymbol$8('iterator'); + var ArrayValues = ArrayIteratorMethods.values; + + var handlePrototype$1 = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty$2(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + setToStringTag$1(CollectionPrototype, COLLECTION_NAME, true); + if (DOMIterables$1[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty$2(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } + }; + + for (var COLLECTION_NAME$1 in DOMIterables$1) { + handlePrototype$1(global$6[COLLECTION_NAME$1] && global$6[COLLECTION_NAME$1].prototype, COLLECTION_NAME$1); + } + + handlePrototype$1(DOMTokenListPrototype$1, 'DOMTokenList'); + + var toObject$7 = toObject$a; + var toAbsoluteIndex$2 = toAbsoluteIndex$4; + var lengthOfArrayLike$6 = lengthOfArrayLike$9; + + // `Array.prototype.fill` method implementation + // https://tc39.es/ecma262/#sec-array.prototype.fill + var arrayFill = function fill(value /* , start = 0, end = @length */) { + var O = toObject$7(this); + var length = lengthOfArrayLike$6(O); + var argumentsLength = arguments.length; + var index = toAbsoluteIndex$2(argumentsLength > 1 ? arguments[1] : undefined, length); + var end = argumentsLength > 2 ? arguments[2] : undefined; + var endPos = end === undefined ? length : toAbsoluteIndex$2(end, length); + while (endPos > index) O[index++] = value; + return O; + }; + + var $$h = _export; + var fill = arrayFill; + var addToUnscopables$1 = addToUnscopables$3; + + // `Array.prototype.fill` method + // https://tc39.es/ecma262/#sec-array.prototype.fill + $$h({ target: 'Array', proto: true }, { + fill: fill + }); + + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + addToUnscopables$1('fill'); + + var classof$4 = classofRaw$2; + + // `IsArray` abstract operation + // https://tc39.es/ecma262/#sec-isarray + // eslint-disable-next-line es/no-array-isarray -- safe + var isArray$5 = Array.isArray || function isArray(argument) { + return classof$4(argument) === 'Array'; + }; + + var toPropertyKey = toPropertyKey$3; + var definePropertyModule = objectDefineProperty; + var createPropertyDescriptor = createPropertyDescriptor$4; + + var createProperty$4 = function (object, key, value) { + var propertyKey = toPropertyKey(key); + if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; + }; + + var fails$h = fails$u; + var wellKnownSymbol$7 = wellKnownSymbol$m; + var V8_VERSION$1 = engineV8Version; + + var SPECIES$3 = wellKnownSymbol$7('species'); + + var arrayMethodHasSpeciesSupport$4 = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return V8_VERSION$1 >= 51 || !fails$h(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES$3] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); + }; + + var $$g = _export; + var isArray$4 = isArray$5; + var isConstructor$2 = isConstructor$4; + var isObject$a = isObject$j; + var toAbsoluteIndex$1 = toAbsoluteIndex$4; + var lengthOfArrayLike$5 = lengthOfArrayLike$9; + var toIndexedObject$3 = toIndexedObject$9; + var createProperty$3 = createProperty$4; + var wellKnownSymbol$6 = wellKnownSymbol$m; + var arrayMethodHasSpeciesSupport$3 = arrayMethodHasSpeciesSupport$4; + var nativeSlice = arraySlice$3; + + var HAS_SPECIES_SUPPORT$2 = arrayMethodHasSpeciesSupport$3('slice'); + + var SPECIES$2 = wellKnownSymbol$6('species'); + var $Array$3 = Array; + var max$2 = Math.max; + + // `Array.prototype.slice` method + // https://tc39.es/ecma262/#sec-array.prototype.slice + // fallback for not array-like ES3 strings and DOM objects + $$g({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$2 }, { + slice: function slice(start, end) { + var O = toIndexedObject$3(this); + var length = lengthOfArrayLike$5(O); + var k = toAbsoluteIndex$1(start, length); + var fin = toAbsoluteIndex$1(end === undefined ? length : end, length); + // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible + var Constructor, result, n; + if (isArray$4(O)) { + Constructor = O.constructor; + // cross-realm fallback + if (isConstructor$2(Constructor) && (Constructor === $Array$3 || isArray$4(Constructor.prototype))) { + Constructor = undefined; + } else if (isObject$a(Constructor)) { + Constructor = Constructor[SPECIES$2]; + if (Constructor === null) Constructor = undefined; + } + if (Constructor === $Array$3 || Constructor === undefined) { + return nativeSlice(O, k, fin); + } + } + result = new (Constructor === undefined ? $Array$3 : Constructor)(max$2(fin - k, 0)); + for (n = 0; k < fin; k++, n++) if (k in O) createProperty$3(result, n, O[k]); + result.length = n; + return result; + } + }); + + /****************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + /* global Reflect, Promise */ + + + function __awaiter(thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); + } + + function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); + } + + var eventemitter3 = {exports: {}}; + + (function (module) { + + var has = Object.prototype.hasOwnProperty + , prefix = '~'; + + /** + * Constructor to create a storage for our `EE` objects. + * An `Events` instance is a plain object whose properties are event names. + * + * @constructor + * @private + */ + function Events() {} + + // + // We try to not inherit from `Object.prototype`. In some engines creating an + // instance in this way is faster than calling `Object.create(null)` directly. + // If `Object.create(null)` is not supported we prefix the event names with a + // character to make sure that the built-in object properties are not + // overridden or used as an attack vector. + // + if (Object.create) { + Events.prototype = Object.create(null); + + // + // This hack is needed because the `__proto__` property is still inherited in + // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5. + // + if (!new Events().__proto__) prefix = false; + } + + /** + * Representation of a single event listener. + * + * @param {Function} fn The listener function. + * @param {*} context The context to invoke the listener with. + * @param {Boolean} [once=false] Specify if the listener is a one-time listener. + * @constructor + * @private + */ + function EE(fn, context, once) { + this.fn = fn; + this.context = context; + this.once = once || false; + } + + /** + * Add a listener for a given event. + * + * @param {EventEmitter} emitter Reference to the `EventEmitter` instance. + * @param {(String|Symbol)} event The event name. + * @param {Function} fn The listener function. + * @param {*} context The context to invoke the listener with. + * @param {Boolean} once Specify if the listener is a one-time listener. + * @returns {EventEmitter} + * @private + */ + function addListener(emitter, event, fn, context, once) { + if (typeof fn !== 'function') { + throw new TypeError('The listener must be a function'); + } + + var listener = new EE(fn, context || emitter, once) + , evt = prefix ? prefix + event : event; + + if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++; + else if (!emitter._events[evt].fn) emitter._events[evt].push(listener); + else emitter._events[evt] = [emitter._events[evt], listener]; + + return emitter; + } + + /** + * Clear event by name. + * + * @param {EventEmitter} emitter Reference to the `EventEmitter` instance. + * @param {(String|Symbol)} evt The Event name. + * @private + */ + function clearEvent(emitter, evt) { + if (--emitter._eventsCount === 0) emitter._events = new Events(); + else delete emitter._events[evt]; + } + + /** + * Minimal `EventEmitter` interface that is molded against the Node.js + * `EventEmitter` interface. + * + * @constructor + * @public + */ + function EventEmitter() { + this._events = new Events(); + this._eventsCount = 0; + } + + /** + * Return an array listing the events for which the emitter has registered + * listeners. + * + * @returns {Array} + * @public + */ + EventEmitter.prototype.eventNames = function eventNames() { + var names = [] + , events + , name; + + if (this._eventsCount === 0) return names; + + for (name in (events = this._events)) { + if (has.call(events, name)) names.push(prefix ? name.slice(1) : name); + } + + if (Object.getOwnPropertySymbols) { + return names.concat(Object.getOwnPropertySymbols(events)); + } + + return names; + }; + + /** + * Return the listeners registered for a given event. + * + * @param {(String|Symbol)} event The event name. + * @returns {Array} The registered listeners. + * @public + */ + EventEmitter.prototype.listeners = function listeners(event) { + var evt = prefix ? prefix + event : event + , handlers = this._events[evt]; + + if (!handlers) return []; + if (handlers.fn) return [handlers.fn]; + + for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) { + ee[i] = handlers[i].fn; + } + + return ee; + }; + + /** + * Return the number of listeners listening to a given event. + * + * @param {(String|Symbol)} event The event name. + * @returns {Number} The number of listeners. + * @public + */ + EventEmitter.prototype.listenerCount = function listenerCount(event) { + var evt = prefix ? prefix + event : event + , listeners = this._events[evt]; + + if (!listeners) return 0; + if (listeners.fn) return 1; + return listeners.length; + }; + + /** + * Calls each of the listeners registered for a given event. + * + * @param {(String|Symbol)} event The event name. + * @returns {Boolean} `true` if the event had listeners, else `false`. + * @public + */ + EventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) { + var evt = prefix ? prefix + event : event; + + if (!this._events[evt]) return false; + + var listeners = this._events[evt] + , len = arguments.length + , args + , i; + + if (listeners.fn) { + if (listeners.once) this.removeListener(event, listeners.fn, undefined, true); + + switch (len) { + case 1: return listeners.fn.call(listeners.context), true; + case 2: return listeners.fn.call(listeners.context, a1), true; + case 3: return listeners.fn.call(listeners.context, a1, a2), true; + case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true; + case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true; + case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true; + } + + for (i = 1, args = new Array(len -1); i < len; i++) { + args[i - 1] = arguments[i]; + } + + listeners.fn.apply(listeners.context, args); + } else { + var length = listeners.length + , j; + + for (i = 0; i < length; i++) { + if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true); + + switch (len) { + case 1: listeners[i].fn.call(listeners[i].context); break; + case 2: listeners[i].fn.call(listeners[i].context, a1); break; + case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break; + case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break; + default: + if (!args) for (j = 1, args = new Array(len -1); j < len; j++) { + args[j - 1] = arguments[j]; + } + + listeners[i].fn.apply(listeners[i].context, args); + } + } + } + + return true; + }; + + /** + * Add a listener for a given event. + * + * @param {(String|Symbol)} event The event name. + * @param {Function} fn The listener function. + * @param {*} [context=this] The context to invoke the listener with. + * @returns {EventEmitter} `this`. + * @public + */ + EventEmitter.prototype.on = function on(event, fn, context) { + return addListener(this, event, fn, context, false); + }; + + /** + * Add a one-time listener for a given event. + * + * @param {(String|Symbol)} event The event name. + * @param {Function} fn The listener function. + * @param {*} [context=this] The context to invoke the listener with. + * @returns {EventEmitter} `this`. + * @public + */ + EventEmitter.prototype.once = function once(event, fn, context) { + return addListener(this, event, fn, context, true); + }; + + /** + * Remove the listeners of a given event. + * + * @param {(String|Symbol)} event The event name. + * @param {Function} fn Only remove the listeners that match this function. + * @param {*} context Only remove the listeners that have this context. + * @param {Boolean} once Only remove one-time listeners. + * @returns {EventEmitter} `this`. + * @public + */ + EventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) { + var evt = prefix ? prefix + event : event; + + if (!this._events[evt]) return this; + if (!fn) { + clearEvent(this, evt); + return this; + } + + var listeners = this._events[evt]; + + if (listeners.fn) { + if ( + listeners.fn === fn && + (!once || listeners.once) && + (!context || listeners.context === context) + ) { + clearEvent(this, evt); + } + } else { + for (var i = 0, events = [], length = listeners.length; i < length; i++) { + if ( + listeners[i].fn !== fn || + (once && !listeners[i].once) || + (context && listeners[i].context !== context) + ) { + events.push(listeners[i]); + } + } + + // + // Reset the array, or remove it completely if we have no more listeners. + // + if (events.length) this._events[evt] = events.length === 1 ? events[0] : events; + else clearEvent(this, evt); + } + + return this; + }; + + /** + * Remove all listeners, or those of the specified event. + * + * @param {(String|Symbol)} [event] The event name. + * @returns {EventEmitter} `this`. + * @public + */ + EventEmitter.prototype.removeAllListeners = function removeAllListeners(event) { + var evt; + + if (event) { + evt = prefix ? prefix + event : event; + if (this._events[evt]) clearEvent(this, evt); + } else { + this._events = new Events(); + this._eventsCount = 0; + } + + return this; + }; + + // + // Alias methods names because people roll like that. + // + EventEmitter.prototype.off = EventEmitter.prototype.removeListener; + EventEmitter.prototype.addListener = EventEmitter.prototype.on; + + // + // Expose the prefix. + // + EventEmitter.prefixed = prefix; + + // + // Allow `EventEmitter` to be imported as module namespace. + // + EventEmitter.EventEmitter = EventEmitter; + + // + // Expose the module. + // + { + module.exports = EventEmitter; + } + } (eventemitter3)); + + var eventemitter3Exports = eventemitter3.exports; + var EventEmitter = /*@__PURE__*/getDefaultExportFromCjs(eventemitter3Exports); + + /** + * Checks if `value` is classified as an `Array` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array, else `false`. + * @example + * + * _.isArray([1, 2, 3]); + * // => true + * + * _.isArray(document.body.children); + * // => false + * + * _.isArray('abc'); + * // => false + * + * _.isArray(_.noop); + * // => false + */ + var isArray$2 = Array.isArray; + + var isArray$3 = isArray$2; + + /** + * Casts `value` as an array if it's not one. + * + * @static + * @memberOf _ + * @since 4.4.0 + * @category Lang + * @param {*} value The value to inspect. + * @returns {Array} Returns the cast array. + * @example + * + * _.castArray(1); + * // => [1] + * + * _.castArray({ 'a': 1 }); + * // => [{ 'a': 1 }] + * + * _.castArray('abc'); + * // => ['abc'] + * + * _.castArray(null); + * // => [null] + * + * _.castArray(undefined); + * // => [undefined] + * + * _.castArray(); + * // => [] + * + * var array = [1, 2, 3]; + * console.log(_.castArray(array) === array); + * // => true + */ + function castArray() { + if (!arguments.length) { + return []; + } + var value = arguments[0]; + return isArray$3(value) ? value : [value]; + } + + var isArray$1 = isArray$5; + var isConstructor$1 = isConstructor$4; + var isObject$9 = isObject$j; + var wellKnownSymbol$5 = wellKnownSymbol$m; + + var SPECIES$1 = wellKnownSymbol$5('species'); + var $Array$2 = Array; + + // a part of `ArraySpeciesCreate` abstract operation + // https://tc39.es/ecma262/#sec-arrayspeciescreate + var arraySpeciesConstructor$1 = function (originalArray) { + var C; + if (isArray$1(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor$1(C) && (C === $Array$2 || isArray$1(C.prototype))) C = undefined; + else if (isObject$9(C)) { + C = C[SPECIES$1]; + if (C === null) C = undefined; + } + } return C === undefined ? $Array$2 : C; + }; + + var arraySpeciesConstructor = arraySpeciesConstructor$1; + + // `ArraySpeciesCreate` abstract operation + // https://tc39.es/ecma262/#sec-arrayspeciescreate + var arraySpeciesCreate$2 = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); + }; + + var bind$2 = functionBindContext; + var uncurryThis$f = functionUncurryThis; + var IndexedObject$2 = indexedObject; + var toObject$6 = toObject$a; + var lengthOfArrayLike$4 = lengthOfArrayLike$9; + var arraySpeciesCreate$1 = arraySpeciesCreate$2; + + var push$3 = uncurryThis$f([].push); + + // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation + var createMethod$2 = function (TYPE) { + var IS_MAP = TYPE === 1; + var IS_FILTER = TYPE === 2; + var IS_SOME = TYPE === 3; + var IS_EVERY = TYPE === 4; + var IS_FIND_INDEX = TYPE === 6; + var IS_FILTER_REJECT = TYPE === 7; + var NO_HOLES = TYPE === 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject$6($this); + var self = IndexedObject$2(O); + var length = lengthOfArrayLike$4(self); + var boundFunction = bind$2(callbackfn, that); + var index = 0; + var create = specificCreate || arraySpeciesCreate$1; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push$3(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push$3(target, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; + }; + + var arrayIteration = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod$2(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod$2(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod$2(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod$2(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod$2(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod$2(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod$2(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod$2(7) + }; + + var $$f = _export; + var $map = arrayIteration.map; + var arrayMethodHasSpeciesSupport$2 = arrayMethodHasSpeciesSupport$4; + + var HAS_SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport$2('map'); + + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + // with adding support of @@species + $$f({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$1 }, { + map: function map(callbackfn /* , thisArg */) { + return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } + }); + + var DESCRIPTORS$3 = descriptors; + var uncurryThis$e = functionUncurryThis; + var call$4 = functionCall; + var fails$g = fails$u; + var objectKeys$1 = objectKeys$3; + var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; + var propertyIsEnumerableModule = objectPropertyIsEnumerable; + var toObject$5 = toObject$a; + var IndexedObject$1 = indexedObject; + + // eslint-disable-next-line es/no-object-assign -- safe + var $assign = Object.assign; + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + var defineProperty$3 = Object.defineProperty; + var concat$1 = uncurryThis$e([].concat); + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + var objectAssign = !$assign || fails$g(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$3 && $assign({ b: 1 }, $assign(defineProperty$3({}, 'a', { + enumerable: true, + get: function () { + defineProperty$3(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys$1($assign({}, B)).join('') !== alphabet; + }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject$5(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject$1(arguments[index++]); + var keys = getOwnPropertySymbols ? concat$1(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$3 || call$4(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; + } : $assign; + + var $$e = _export; + var assign = objectAssign; + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + // eslint-disable-next-line es/no-object-assign -- required for testing + $$e({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign + }); + + var internalMetadata = {exports: {}}; + + var objectGetOwnPropertyNamesExternal = {}; + + var toAbsoluteIndex = toAbsoluteIndex$4; + var lengthOfArrayLike$3 = lengthOfArrayLike$9; + var createProperty$2 = createProperty$4; + + var $Array$1 = Array; + var max$1 = Math.max; + + var arraySliceSimple = function (O, start, end) { + var length = lengthOfArrayLike$3(O); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + var result = $Array$1(max$1(fin - k, 0)); + var n = 0; + for (; k < fin; k++, n++) createProperty$2(result, n, O[k]); + result.length = n; + return result; + }; + + /* eslint-disable es/no-object-getownpropertynames -- safe */ + var classof$3 = classofRaw$2; + var toIndexedObject$2 = toIndexedObject$9; + var $getOwnPropertyNames = objectGetOwnPropertyNames.f; + var arraySlice$1 = arraySliceSimple; + + var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + + var getWindowNames = function (it) { + try { + return $getOwnPropertyNames(it); + } catch (error) { + return arraySlice$1(windowNames); + } + }; + + // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window + objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames(it) { + return windowNames && classof$3(it) === 'Window' + ? getWindowNames(it) + : $getOwnPropertyNames(toIndexedObject$2(it)); + }; + + // FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it + var fails$f = fails$u; + + var arrayBufferNonExtensible = fails$f(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } + }); + + var fails$e = fails$u; + var isObject$8 = isObject$j; + var classof$2 = classofRaw$2; + var ARRAY_BUFFER_NON_EXTENSIBLE = arrayBufferNonExtensible; + + // eslint-disable-next-line es/no-object-isextensible -- safe + var $isExtensible = Object.isExtensible; + var FAILS_ON_PRIMITIVES$1 = fails$e(function () { $isExtensible(1); }); + + // `Object.isExtensible` method + // https://tc39.es/ecma262/#sec-object.isextensible + var objectIsExtensible = (FAILS_ON_PRIMITIVES$1 || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) { + if (!isObject$8(it)) return false; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof$2(it) === 'ArrayBuffer') return false; + return $isExtensible ? $isExtensible(it) : true; + } : $isExtensible; + + var fails$d = fails$u; + + var freezing = !fails$d(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); + }); + + var $$d = _export; + var uncurryThis$d = functionUncurryThis; + var hiddenKeys = hiddenKeys$5; + var isObject$7 = isObject$j; + var hasOwn$1 = hasOwnProperty_1; + var defineProperty$2 = objectDefineProperty.f; + var getOwnPropertyNamesModule = objectGetOwnPropertyNames; + var getOwnPropertyNamesExternalModule = objectGetOwnPropertyNamesExternal; + var isExtensible = objectIsExtensible; + var uid = uid$3; + var FREEZING = freezing; + + var REQUIRED = false; + var METADATA = uid('meta'); + var id$1 = 0; + + var setMetadata = function (it) { + defineProperty$2(it, METADATA, { value: { + objectID: 'O' + id$1++, // object ID + weakData: {} // weak collections IDs + } }); + }; + + var fastKey$1 = function (it, create) { + // return a primitive with prefix + if (!isObject$7(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; + }; + + var getWeakData$1 = function (it, create) { + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; + }; + + // add metadata on freeze-family methods calling + var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn$1(it, METADATA)) setMetadata(it); + return it; + }; + + var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis$d([].splice); + var test = {}; + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $$d({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } + }; + + var meta = internalMetadata.exports = { + enable: enable, + fastKey: fastKey$1, + getWeakData: getWeakData$1, + onFreeze: onFreeze + }; + + hiddenKeys[METADATA] = true; + + var internalMetadataExports = internalMetadata.exports; + + var isCallable$3 = isCallable$o; + var isObject$6 = isObject$j; + var setPrototypeOf = objectSetPrototypeOf; + + // makes subclassing work correct for wrapped built-ins + var inheritIfRequired$1 = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable$3(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject$6(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; + }; + + var $$c = _export; + var global$5 = global$n; + var uncurryThis$c = functionUncurryThis; + var isForced = isForced_1; + var defineBuiltIn$2 = defineBuiltIn$9; + var InternalMetadataModule = internalMetadataExports; + var iterate$2 = iterate$6; + var anInstance$2 = anInstance$4; + var isCallable$2 = isCallable$o; + var isNullOrUndefined$3 = isNullOrUndefined$8; + var isObject$5 = isObject$j; + var fails$c = fails$u; + var checkCorrectnessOfIteration$1 = checkCorrectnessOfIteration$3; + var setToStringTag = setToStringTag$5; + var inheritIfRequired = inheritIfRequired$1; + + var collection$3 = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global$5[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis$c(NativePrototype[KEY]); + defineBuiltIn$2(NativePrototype, KEY, + KEY === 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY === 'delete' ? function (key) { + return IS_WEAK && !isObject$5(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'get' ? function get(key) { + return IS_WEAK && !isObject$5(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'has' ? function has(key) { + return IS_WEAK && !isObject$5(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable$2(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails$c(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails$c(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration$1(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails$c(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance$2(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (!isNullOrUndefined$3(iterable)) iterate$2(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $$c({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported); + + setToStringTag(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; + }; + + var defineBuiltIn$1 = defineBuiltIn$9; + + var defineBuiltIns$2 = function (target, src, options) { + for (var key in src) defineBuiltIn$1(target, key, src[key], options); + return target; + }; + + var uncurryThis$b = functionUncurryThis; + var defineBuiltIns$1 = defineBuiltIns$2; + var getWeakData = internalMetadataExports.getWeakData; + var anInstance$1 = anInstance$4; + var anObject$4 = anObject$f; + var isNullOrUndefined$2 = isNullOrUndefined$8; + var isObject$4 = isObject$j; + var iterate$1 = iterate$6; + var ArrayIterationModule = arrayIteration; + var hasOwn = hasOwnProperty_1; + var InternalStateModule$1 = internalState; + + var setInternalState$1 = InternalStateModule$1.set; + var internalStateGetterFor$1 = InternalStateModule$1.getterFor; + var find = ArrayIterationModule.find; + var findIndex = ArrayIterationModule.findIndex; + var splice$1 = uncurryThis$b([].splice); + var id = 0; + + // fallback for uncaught frozen keys + var uncaughtFrozenStore = function (state) { + return state.frozen || (state.frozen = new UncaughtFrozenStore()); + }; + + var UncaughtFrozenStore = function () { + this.entries = []; + }; + + var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); + }; + + UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) splice$1(this.entries, index, 1); + return !!~index; + } + }; + + var collectionWeak$1 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance$1(that, Prototype); + setInternalState$1(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (!isNullOrUndefined$2(iterable)) iterate$1(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor$1(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject$4(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + defineBuiltIns$1(Prototype, { + // `{ WeakMap, WeakSet }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.delete + // https://tc39.es/ecma262/#sec-weakset.prototype.delete + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject$4(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && hasOwn(data, state.id) && delete data[state.id]; + }, + // `{ WeakMap, WeakSet }.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.has + // https://tc39.es/ecma262/#sec-weakset.prototype.has + has: function has(key) { + var state = getInternalState(this); + if (!isObject$4(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && hasOwn(data, state.id); + } + }); + + defineBuiltIns$1(Prototype, IS_MAP ? { + // `WeakMap.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.get + get: function get(key) { + var state = getInternalState(this); + if (isObject$4(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // `WeakMap.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.set + set: function set(key, value) { + return define(this, key, value); + } + } : { + // `WeakSet.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-weakset.prototype.add + add: function add(value) { + return define(this, value, true); + } + }); + + return Constructor; + } + }; + + var collection$2 = collection$3; + var collectionWeak = collectionWeak$1; + + // `WeakSet` constructor + // https://tc39.es/ecma262/#sec-weakset-constructor + collection$2('WeakSet', function (init) { + return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); }; + }, collectionWeak); + + var ScrollDirection; + (function (ScrollDirection) { + ScrollDirection[ScrollDirection["SCROLL_NONE"] = 0] = "SCROLL_NONE"; + ScrollDirection[ScrollDirection["SCROLL_BACKWARD"] = 1] = "SCROLL_BACKWARD"; + ScrollDirection[ScrollDirection["SCROLL_FORWARD"] = 2] = "SCROLL_FORWARD"; + })(ScrollDirection || (ScrollDirection = {})); + var Position; + (function (Position) { + Position[Position["TOP"] = 0] = "TOP"; + Position[Position["RIGHT"] = 1] = "RIGHT"; + Position[Position["BOTTOM"] = 2] = "BOTTOM"; + Position[Position["LEFT"] = 3] = "LEFT"; + })(Position || (Position = {})); + var OPTIONS_DEFAULT_DOMAIN_TYPE = 'hour'; + var OPTIONS_DEFAULT_SUBDOMAIN_TYPE = 'minute'; + var OPTIONS_DEFAULT_SUBDOMAIN_WIDTH = 10; + var OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT = 10; + var OPTIONS_DEFAULT_SUBDOMAIN_GUTTER = 2; + var OPTIONS_DEFAULT_SUBDOMAIN_RADIUS = 0; + var OPTIONS_DEFAULT_ANIMATION_DURATION = 200; + var OPTIONS_DEFAULT_RANGE = 12; + var OPTIONS_DEFAULT_ITEM_SELECTOR = '#cal-heatmap'; + var OPTIONS_DEFAULT_THEME = 'light'; + var OPTIONS_DEFAULT_LOCALE = 'en'; + var SCALE_BASE_OPACITY_COLOR = 'red'; + var SCALE_BASE_COLOR_SCHEME = 'YlOrBr'; + var SCALE_BASE_COLOR_TYPE = 'quantize'; + var SCALE_BASE_COLOR_DOMAIN = [0, 100]; + + var _Navigator_instances, _Navigator_isDomainBoundaryReached, _Navigator_setDomainsBoundaryReached; + var Navigator = /*#__PURE__*/function () { + function Navigator(calendar) { + _classCallCheck(this, Navigator); + _Navigator_instances.add(this); + this.calendar = calendar; + this.maxDomainReached = false; + this.minDomainReached = false; + } + _createClass(Navigator, [{ + key: "loadNewDomains", + value: function loadNewDomains(newDomainCollection) { + var _this = this; + var direction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : ScrollDirection.SCROLL_NONE; + var options = this.calendar.options.options; + var templatesClt = this.calendar.templateCollection; + var minDate = options.date.min ? templatesClt.get(options.domain.type).extractUnit(+options.date.min) : undefined; + var maxDate = options.date.max ? templatesClt.get(options.domain.type).extractUnit(+options.date.max) : undefined; + var domainCollection = this.calendar.domainCollection; + if (__classPrivateFieldGet(this, _Navigator_instances, "m", _Navigator_isDomainBoundaryReached).call(this, newDomainCollection, minDate, maxDate, direction)) { + return ScrollDirection.SCROLL_NONE; + } + if (direction !== ScrollDirection.SCROLL_NONE) { + newDomainCollection.clamp(minDate, maxDate).slice(options.range, direction === ScrollDirection.SCROLL_FORWARD); + } + domainCollection.merge(newDomainCollection, options.range, function (domainKey, index) { + var subDomainEndDate = null; + if (newDomainCollection.at(index + 1)) { + subDomainEndDate = newDomainCollection.at(index + 1); + } else { + subDomainEndDate = _this.calendar.dateHelper.intervals(options.domain.type, domainKey, 2).pop(); + } + return templatesClt.get(options.subDomain.type).mapping(domainKey, subDomainEndDate).map(function (d) { + return Object.assign(Object.assign({}, d), { + v: options.data.defaultValue + }); + }); + }); + __classPrivateFieldGet(this, _Navigator_instances, "m", _Navigator_setDomainsBoundaryReached).call(this, domainCollection.min, domainCollection.max, minDate, maxDate); + if (direction === ScrollDirection.SCROLL_BACKWARD) { + this.calendar.eventEmitter.emit('domainsLoaded', [domainCollection.min]); + } else if (direction === ScrollDirection.SCROLL_FORWARD) { + this.calendar.eventEmitter.emit('domainsLoaded', [domainCollection.max]); + } + return direction; + } + }, { + key: "jumpTo", + value: function jumpTo(date, reset) { + var _this$calendar = this.calendar, + domainCollection = _this$calendar.domainCollection, + options = _this$calendar.options; + var minDate = new Date(domainCollection.min); + var maxDate = new Date(domainCollection.max); + if (date < minDate) { + return this.loadNewDomains(this.calendar.createDomainCollection(date, minDate, false), ScrollDirection.SCROLL_BACKWARD); + } + if (reset) { + return this.loadNewDomains(this.calendar.createDomainCollection(date, options.options.range), minDate < date ? ScrollDirection.SCROLL_FORWARD : ScrollDirection.SCROLL_BACKWARD); + } + if (date > maxDate) { + return this.loadNewDomains(this.calendar.createDomainCollection(maxDate, date, false), ScrollDirection.SCROLL_FORWARD); + } + return ScrollDirection.SCROLL_NONE; + } + }]); + return Navigator; + }(); + _Navigator_instances = new WeakSet(), _Navigator_isDomainBoundaryReached = function _Navigator_isDomainBoundaryReached(newDomainCollection, minDate, maxDate, direction) { + if (maxDate && newDomainCollection.max >= maxDate && this.maxDomainReached && direction === ScrollDirection.SCROLL_FORWARD) { + return true; + } + if (minDate && newDomainCollection.min <= minDate && this.minDomainReached && direction === ScrollDirection.SCROLL_BACKWARD) { + return true; + } + return false; + }, _Navigator_setDomainsBoundaryReached = function _Navigator_setDomainsBoundaryReached(lowerBound, upperBound, min, max) { + if (min) { + var reached = lowerBound <= min; + this.calendar.eventEmitter.emit(reached ? 'minDateReached' : 'minDateNotReached'); + this.minDomainReached = reached; + } + if (max) { + var _reached = upperBound >= max; + this.calendar.eventEmitter.emit(_reached ? 'maxDateReached' : 'maxDateNotReached'); + this.maxDomainReached = _reached; + } + }; + + var $TypeError$3 = TypeError; + var MAX_SAFE_INTEGER$2 = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991 + + var doesNotExceedSafeInteger$1 = function (it) { + if (it > MAX_SAFE_INTEGER$2) throw $TypeError$3('Maximum allowed index exceeded'); + return it; + }; + + var $$b = _export; + var fails$b = fails$u; + var isArray = isArray$5; + var isObject$3 = isObject$j; + var toObject$4 = toObject$a; + var lengthOfArrayLike$2 = lengthOfArrayLike$9; + var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1; + var createProperty$1 = createProperty$4; + var arraySpeciesCreate = arraySpeciesCreate$2; + var arrayMethodHasSpeciesSupport$1 = arrayMethodHasSpeciesSupport$4; + var wellKnownSymbol$4 = wellKnownSymbol$m; + var V8_VERSION = engineV8Version; + + var IS_CONCAT_SPREADABLE = wellKnownSymbol$4('isConcatSpreadable'); + + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/679 + var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails$b(function () { + var array = []; + array[IS_CONCAT_SPREADABLE] = false; + return array.concat()[0] !== array; + }); + + var isConcatSpreadable = function (O) { + if (!isObject$3(O)) return false; + var spreadable = O[IS_CONCAT_SPREADABLE]; + return spreadable !== undefined ? !!spreadable : isArray(O); + }; + + var FORCED$2 = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport$1('concat'); + + // `Array.prototype.concat` method + // https://tc39.es/ecma262/#sec-array.prototype.concat + // with adding support of @@isConcatSpreadable and @@species + $$b({ target: 'Array', proto: true, arity: 1, forced: FORCED$2 }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + concat: function concat(arg) { + var O = toObject$4(this); + var A = arraySpeciesCreate(O, 0); + var n = 0; + var i, k, length, len, E; + for (i = -1, length = arguments.length; i < length; i++) { + E = i === -1 ? O : arguments[i]; + if (isConcatSpreadable(E)) { + len = lengthOfArrayLike$2(E); + doesNotExceedSafeInteger(n + len); + for (k = 0; k < len; k++, n++) if (k in E) createProperty$1(A, n, E[k]); + } else { + doesNotExceedSafeInteger(n + 1); + createProperty$1(A, n++, E); + } + } + A.length = n; + return A; + } + }); + + var fails$a = fails$u; + + var arrayMethodIsStrict$3 = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails$a(function () { + // eslint-disable-next-line no-useless-call -- required for testing + method.call(null, argument || function () { return 1; }, 1); + }); + }; + + var $$a = _export; + var uncurryThis$a = functionUncurryThis; + var IndexedObject = indexedObject; + var toIndexedObject$1 = toIndexedObject$9; + var arrayMethodIsStrict$2 = arrayMethodIsStrict$3; + + var nativeJoin = uncurryThis$a([].join); + + var ES3_STRINGS = IndexedObject !== Object; + var FORCED$1 = ES3_STRINGS || !arrayMethodIsStrict$2('join', ','); + + // `Array.prototype.join` method + // https://tc39.es/ecma262/#sec-array.prototype.join + $$a({ target: 'Array', proto: true, forced: FORCED$1 }, { + join: function join(separator) { + return nativeJoin(toIndexedObject$1(this), separator === undefined ? ',' : separator); + } + }); + + var create$1 = objectCreate$1; + var defineBuiltInAccessor$1 = defineBuiltInAccessor$3; + var defineBuiltIns = defineBuiltIns$2; + var bind$1 = functionBindContext; + var anInstance = anInstance$4; + var isNullOrUndefined$1 = isNullOrUndefined$8; + var iterate = iterate$6; + var defineIterator = iteratorDefine; + var createIterResultObject = createIterResultObject$3; + var setSpecies = setSpecies$2; + var DESCRIPTORS$2 = descriptors; + var fastKey = internalMetadataExports.fastKey; + var InternalStateModule = internalState; + + var setInternalState = InternalStateModule.set; + var internalStateGetterFor = InternalStateModule.getterFor; + + var collectionStrong$2 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + index: create$1(null), + first: undefined, + last: undefined, + size: 0 + }); + if (!DESCRIPTORS$2) that.size = 0; + if (!isNullOrUndefined$1(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + // change existing entry + if (entry) { + entry.value = value; + // create new entry + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: undefined, + removed: false + }; + if (!state.first) state.first = entry; + if (previous) previous.next = entry; + if (DESCRIPTORS$2) state.size++; + else that.size++; + // add to index + if (index !== 'F') state.index[index] = entry; + } return that; + }; + + var getEntry = function (that, key) { + var state = getInternalState(that); + // fast case + var index = fastKey(key); + var entry; + if (index !== 'F') return state.index[index]; + // frozen object case + for (entry = state.first; entry; entry = entry.next) { + if (entry.key === key) return entry; + } + }; + + defineBuiltIns(Prototype, { + // `{ Map, Set }.prototype.clear()` methods + // https://tc39.es/ecma262/#sec-map.prototype.clear + // https://tc39.es/ecma262/#sec-set.prototype.clear + clear: function clear() { + var that = this; + var state = getInternalState(that); + var data = state.index; + var entry = state.first; + while (entry) { + entry.removed = true; + if (entry.previous) entry.previous = entry.previous.next = undefined; + delete data[entry.index]; + entry = entry.next; + } + state.first = state.last = undefined; + if (DESCRIPTORS$2) state.size = 0; + else that.size = 0; + }, + // `{ Map, Set }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.delete + // https://tc39.es/ecma262/#sec-set.prototype.delete + 'delete': function (key) { + var that = this; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) prev.next = next; + if (next) next.previous = prev; + if (state.first === entry) state.first = next; + if (state.last === entry) state.last = prev; + if (DESCRIPTORS$2) state.size--; + else that.size--; + } return !!entry; + }, + // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods + // https://tc39.es/ecma262/#sec-map.prototype.foreach + // https://tc39.es/ecma262/#sec-set.prototype.foreach + forEach: function forEach(callbackfn /* , that = undefined */) { + var state = getInternalState(this); + var boundFunction = bind$1(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var entry; + while (entry = entry ? entry.next : state.first) { + boundFunction(entry.value, entry.key, this); + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + } + }, + // `{ Map, Set}.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.has + // https://tc39.es/ecma262/#sec-set.prototype.has + has: function has(key) { + return !!getEntry(this, key); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `Map.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-map.prototype.get + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + // `Map.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-map.prototype.set + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + // `Set.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-set.prototype.add + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (DESCRIPTORS$2) defineBuiltInAccessor$1(Prototype, 'size', { + configurable: true, + get: function () { + return getInternalState(this).size; + } + }); + return Constructor; + }, + setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods + // https://tc39.es/ecma262/#sec-map.prototype.entries + // https://tc39.es/ecma262/#sec-map.prototype.keys + // https://tc39.es/ecma262/#sec-map.prototype.values + // https://tc39.es/ecma262/#sec-map.prototype-@@iterator + // https://tc39.es/ecma262/#sec-set.prototype.entries + // https://tc39.es/ecma262/#sec-set.prototype.keys + // https://tc39.es/ecma262/#sec-set.prototype.values + // https://tc39.es/ecma262/#sec-set.prototype-@@iterator + defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: undefined + }); + }, function () { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + // get next entry + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + // or finish the iteration + state.target = undefined; + return createIterResultObject(undefined, true); + } + // return step by kind + if (kind === 'keys') return createIterResultObject(entry.key, false); + if (kind === 'values') return createIterResultObject(entry.value, false); + return createIterResultObject([entry.key, entry.value], false); + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + + // `{ Map, Set }.prototype[@@species]` accessors + // https://tc39.es/ecma262/#sec-get-map-@@species + // https://tc39.es/ecma262/#sec-get-set-@@species + setSpecies(CONSTRUCTOR_NAME); + } + }; + + var collection$1 = collection$3; + var collectionStrong$1 = collectionStrong$2; + + // `Map` constructor + // https://tc39.es/ecma262/#sec-map-objects + collection$1('Map', function (init) { + return function Map() { return init(this, arguments.length ? arguments[0] : undefined); }; + }, collectionStrong$1); + + var tryToString = tryToString$5; + + var $TypeError$2 = TypeError; + + var deletePropertyOrThrow$1 = function (O, P) { + if (!delete O[P]) throw new $TypeError$2('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O)); + }; + + var arraySlice = arraySliceSimple; + + var floor$1 = Math.floor; + + var mergeSort = function (array, comparefn) { + var length = array.length; + var middle = floor$1(length / 2); + return length < 8 ? insertionSort(array, comparefn) : merge( + array, + mergeSort(arraySlice(array, 0, middle), comparefn), + mergeSort(arraySlice(array, middle), comparefn), + comparefn + ); + }; + + var insertionSort = function (array, comparefn) { + var length = array.length; + var i = 1; + var element, j; + + while (i < length) { + j = i; + element = array[i]; + while (j && comparefn(array[j - 1], element) > 0) { + array[j] = array[--j]; + } + if (j !== i++) array[j] = element; + } return array; + }; + + var merge = function (array, left, right, comparefn) { + var llength = left.length; + var rlength = right.length; + var lindex = 0; + var rindex = 0; + + while (lindex < llength || rindex < rlength) { + array[lindex + rindex] = (lindex < llength && rindex < rlength) + ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] + : lindex < llength ? left[lindex++] : right[rindex++]; + } return array; + }; + + var arraySort = mergeSort; + + var userAgent$1 = engineUserAgent; + + var firefox = userAgent$1.match(/firefox\/(\d+)/i); + + var engineFfVersion = !!firefox && +firefox[1]; + + var UA = engineUserAgent; + + var engineIsIeOrEdge = /MSIE|Trident/.test(UA); + + var userAgent = engineUserAgent; + + var webkit = userAgent.match(/AppleWebKit\/(\d+)\./); + + var engineWebkitVersion = !!webkit && +webkit[1]; + + var $$9 = _export; + var uncurryThis$9 = functionUncurryThis; + var aCallable = aCallable$a; + var toObject$3 = toObject$a; + var lengthOfArrayLike$1 = lengthOfArrayLike$9; + var deletePropertyOrThrow = deletePropertyOrThrow$1; + var toString$6 = toString$9; + var fails$9 = fails$u; + var internalSort = arraySort; + var arrayMethodIsStrict$1 = arrayMethodIsStrict$3; + var FF = engineFfVersion; + var IE_OR_EDGE = engineIsIeOrEdge; + var V8 = engineV8Version; + var WEBKIT = engineWebkitVersion; + + var test = []; + var nativeSort = uncurryThis$9(test.sort); + var push$2 = uncurryThis$9(test.push); + + // IE8- + var FAILS_ON_UNDEFINED = fails$9(function () { + test.sort(undefined); + }); + // V8 bug + var FAILS_ON_NULL = fails$9(function () { + test.sort(null); + }); + // Old WebKit + var STRICT_METHOD$1 = arrayMethodIsStrict$1('sort'); + + var STABLE_SORT = !fails$9(function () { + // feature detection can be too slow, so check engines versions + if (V8) return V8 < 70; + if (FF && FF > 3) return; + if (IE_OR_EDGE) return true; + if (WEBKIT) return WEBKIT < 603; + + var result = ''; + var code, chr, value, index; + + // generate an array with more 512 elements (Chakra and old V8 fails only in this case) + for (code = 65; code < 76; code++) { + chr = String.fromCharCode(code); + + switch (code) { + case 66: case 69: case 70: case 72: value = 3; break; + case 68: case 71: value = 4; break; + default: value = 2; + } + + for (index = 0; index < 47; index++) { + test.push({ k: chr + index, v: value }); + } + } + + test.sort(function (a, b) { return b.v - a.v; }); + + for (index = 0; index < test.length; index++) { + chr = test[index].k.charAt(0); + if (result.charAt(result.length - 1) !== chr) result += chr; + } + + return result !== 'DGBEFHACIJK'; + }); + + var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD$1 || !STABLE_SORT; + + var getSortCompare = function (comparefn) { + return function (x, y) { + if (y === undefined) return -1; + if (x === undefined) return 1; + if (comparefn !== undefined) return +comparefn(x, y) || 0; + return toString$6(x) > toString$6(y) ? 1 : -1; + }; + }; + + // `Array.prototype.sort` method + // https://tc39.es/ecma262/#sec-array.prototype.sort + $$9({ target: 'Array', proto: true, forced: FORCED }, { + sort: function sort(comparefn) { + if (comparefn !== undefined) aCallable(comparefn); + + var array = toObject$3(this); + + if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn); + + var items = []; + var arrayLength = lengthOfArrayLike$1(array); + var itemsLength, index; + + for (index = 0; index < arrayLength; index++) { + if (index in array) push$2(items, array[index]); + } + + internalSort(items, getSortCompare(comparefn)); + + itemsLength = lengthOfArrayLike$1(items); + index = 0; + + while (index < itemsLength) array[index] = items[index++]; + while (index < arrayLength) deletePropertyOrThrow(array, index++); + + return array; + } + }); + + var $forEach = arrayIteration.forEach; + var arrayMethodIsStrict = arrayMethodIsStrict$3; + + var STRICT_METHOD = arrayMethodIsStrict('forEach'); + + // `Array.prototype.forEach` method implementation + // https://tc39.es/ecma262/#sec-array.prototype.foreach + var arrayForEach = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + // eslint-disable-next-line es/no-array-prototype-foreach -- safe + } : [].forEach; + + var global$4 = global$n; + var DOMIterables = domIterables; + var DOMTokenListPrototype = domTokenListPrototype; + var forEach = arrayForEach; + var createNonEnumerableProperty$1 = createNonEnumerableProperty$6; + + var handlePrototype = function (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { + createNonEnumerableProperty$1(CollectionPrototype, 'forEach', forEach); + } catch (error) { + CollectionPrototype.forEach = forEach; + } + }; + + for (var COLLECTION_NAME in DOMIterables) { + if (DOMIterables[COLLECTION_NAME]) { + handlePrototype(global$4[COLLECTION_NAME] && global$4[COLLECTION_NAME].prototype); + } + } + + handlePrototype(DOMTokenListPrototype); + + function isVertical(position) { + return position === 'top' || position === 'bottom'; + } + function horizontalPadding(padding) { + return padding[Position.LEFT] + padding[Position.RIGHT]; + } + function verticalPadding(padding) { + return padding[Position.TOP] + padding[Position.BOTTOM]; + } + + var _DomainCoordinates_instances, _DomainCoordinates_getWidth, _DomainCoordinates_getHeight; + var DomainCoordinates = /*#__PURE__*/function () { + function DomainCoordinates(calendar, domainPainter) { + _classCallCheck(this, DomainCoordinates); + _DomainCoordinates_instances.add(this); + this.calendar = calendar; + this.domainPainter = domainPainter; + this.collection = new Map(); + this.scrollDirection = ScrollDirection.SCROLL_FORWARD; + } + _createClass(DomainCoordinates, [{ + key: "get", + value: function get(domainKey) { + return this.collection.get(domainKey); + } + }, { + key: "update", + value: function update(collection, scrollDirection) { + var _this = this; + var _this$calendar$option = this.calendar.options.options, + verticalOrientation = _this$calendar$option.verticalOrientation, + domain = _this$calendar$option.domain; + this.scrollDirection = scrollDirection; + var dimensions = { + width: 0, + height: 0 + }; + var exitingTotal = 0; + var scrollFactor = scrollDirection === ScrollDirection.SCROLL_FORWARD ? -1 : 1; + var keys = collection.keys; + if (this.calendar.options.options.domain.sort === 'desc') { + keys.reverse(); + scrollFactor *= -1; + } + collection.yankedDomains.forEach(function (domainKey) { + exitingTotal += _this.collection.get(domainKey)[verticalOrientation ? 'height' : 'width']; + }); + collection.yankedDomains.forEach(function (domainKey) { + var coor = _this.collection.get(domainKey); + _this.collection.set(domainKey, Object.assign(Object.assign({}, coor), { + x: verticalOrientation ? coor.x : coor.x + exitingTotal * scrollFactor, + y: verticalOrientation ? coor.y + exitingTotal * scrollFactor : coor.y + })); + }); + keys.forEach(function (domainKey) { + var w = __classPrivateFieldGet(_this, _DomainCoordinates_instances, "m", _DomainCoordinates_getWidth).call(_this, domainKey); + var h = __classPrivateFieldGet(_this, _DomainCoordinates_instances, "m", _DomainCoordinates_getHeight).call(_this, domainKey); + if (verticalOrientation) { + dimensions.height += h; + dimensions.width = Math.max(w, dimensions.width); + } else { + dimensions.width += w; + dimensions.height = Math.max(h, dimensions.height); + } + var x = dimensions.width - w; + var y = dimensions.height - h; + _this.collection.set(domainKey, Object.assign(Object.assign({}, _this.collection.get(domainKey)), { + x: verticalOrientation ? 0 : x, + y: verticalOrientation ? y : 0, + pre_x: verticalOrientation ? x : x - exitingTotal * scrollFactor, + pre_y: verticalOrientation ? y - exitingTotal * scrollFactor : y, + width: w, + height: h, + inner_width: w - (verticalOrientation ? 0 : domain.gutter), + inner_height: h - (!verticalOrientation ? 0 : domain.gutter) + })); + }); + return dimensions; + } + }]); + return DomainCoordinates; + }(); + _DomainCoordinates_instances = new WeakSet(), _DomainCoordinates_getWidth = function _DomainCoordinates_getWidth(d) { + var _this$calendar$option2 = this.calendar.options.options, + domain = _this$calendar$option2.domain, + subDomain = _this$calendar$option2.subDomain, + x = _this$calendar$option2.x, + verticalOrientation = _this$calendar$option2.verticalOrientation; + var columnsCount = this.calendar.templateCollection.get(subDomain.type).columnsCount(d); + var subDomainWidth = (subDomain.width + subDomain.gutter) * columnsCount - subDomain.gutter; + return horizontalPadding(domain.padding) + x.domainHorizontalLabelWidth + (verticalOrientation ? 0 : domain.gutter) + subDomainWidth; + }, _DomainCoordinates_getHeight = function _DomainCoordinates_getHeight(d) { + var _this$calendar$option3 = this.calendar.options.options, + domain = _this$calendar$option3.domain, + subDomain = _this$calendar$option3.subDomain, + x = _this$calendar$option3.x, + verticalOrientation = _this$calendar$option3.verticalOrientation; + var rowsCount = this.calendar.templateCollection.get(subDomain.type).rowsCount(d); + var subDomainHeight = (subDomain.height + subDomain.gutter) * rowsCount - subDomain.gutter; + return verticalPadding(domain.padding) + subDomainHeight + (verticalOrientation ? domain.gutter : 0) + x.domainVerticalLabelHeight; + }; + + var _DomainPainter_instances, _DomainPainter_getClassName; + var DEFAULT_SELECTOR$3 = '.ch-domain'; + var DomainPainter = /*#__PURE__*/function () { + function DomainPainter(calendar) { + _classCallCheck(this, DomainPainter); + _DomainPainter_instances.add(this); + this.calendar = calendar; + this.coordinates = new DomainCoordinates(calendar, this); + this.root = null; + // Dimensions of the internal area containing all the domains + // Excluding all surrounding margins + this.dimensions = { + width: 0, + height: 0 + }; + } + _createClass(DomainPainter, [{ + key: "paint", + value: function paint(scrollDirection, rootNode) { + var _this = this; + var animationDuration = this.calendar.options.options.animationDuration; + var t = rootNode.transition().duration(animationDuration); + var coor = this.coordinates; + this.dimensions = coor.update(this.calendar.domainCollection, scrollDirection); + var promises = []; + this.root = rootNode.selectAll(DEFAULT_SELECTOR$3).data(this.calendar.domainCollection.keys, function (d) { + return d; + }).join(function (enter) { + return enter.append('svg').attr('x', function (d) { + return coor.get(d).pre_x; + }).attr('y', function (d) { + return coor.get(d).pre_y; + }).attr('width', function (d) { + return coor.get(d).inner_width; + }).attr('height', function (d) { + return coor.get(d).inner_height; + }).attr('class', function (d) { + return __classPrivateFieldGet(_this, _DomainPainter_instances, "m", _DomainPainter_getClassName).call(_this, d); + }).call(function (enterSelection) { + return enterSelection.append('rect').attr('width', function (d) { + return coor.get(d).inner_width; + }).attr('height', function (d) { + return coor.get(d).inner_height; + }).attr('class', "".concat(DEFAULT_SELECTOR$3.slice(1), "-bg")); + }).call(function (enterSelection) { + return promises.push(enterSelection.transition(t).attr('x', function (d) { + return coor.get(d).x; + }).attr('y', function (d) { + return coor.get(d).y; + }).end()); + }); + }, function (update) { + return update.call(function (updateSelection) { + return promises.push(updateSelection.transition(t).attr('x', function (d) { + return coor.get(d).x; + }).attr('y', function (d) { + return coor.get(d).y; + }).attr('width', function (d) { + return coor.get(d).inner_width; + }).attr('height', function (d) { + return coor.get(d).inner_height; + }).end()); + }).call(function (updateSelection) { + return promises.push(updateSelection.selectAll("".concat(DEFAULT_SELECTOR$3, "-bg")).transition(t).attr('width', function (d) { + return coor.get(d).inner_width; + }).attr('height', function (d) { + return coor.get(d).inner_height; + }).end()); + }); + }, function (exit) { + return exit.call(function (exitSelection) { + return promises.push(exitSelection.transition(t).attr('x', function (d) { + return coor.get(d).x; + }).attr('y', function (d) { + return coor.get(d).y; + }).remove().end()); + }); + }); + return promises; + } + }]); + return DomainPainter; + }(); + _DomainPainter_instances = new WeakSet(), _DomainPainter_getClassName = function _DomainPainter_getClassName(d) { + var classname = DEFAULT_SELECTOR$3.slice(1); + var helper = this.calendar.dateHelper.date(d); + switch (this.calendar.options.options.domain.type) { + case 'hour': + classname += " h_".concat(helper.hour()); + break; + case 'day': + classname += " d_".concat(helper.date(), " dy_").concat(helper.format('d') + 1); + break; + case 'week': + classname += " w_".concat(helper.week()); + break; + case 'month': + classname += " m_".concat(helper.month() + 1); + break; + case 'year': + classname += " y_".concat(helper.year()); + break; + } + return classname; + }; + + var $$8 = _export; + var $includes = arrayIncludes.includes; + var fails$8 = fails$u; + var addToUnscopables = addToUnscopables$3; + + // FF99+ bug + var BROKEN_ON_SPARSE = fails$8(function () { + // eslint-disable-next-line es/no-array-prototype-includes -- detection + return !Array(1).includes(); + }); + + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + $$8({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, { + includes: function includes(el /* , fromIndex = 0 */) { + return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); + } + }); + + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + addToUnscopables('includes'); + + var $$7 = _export; + var $filter = arrayIteration.filter; + var arrayMethodHasSpeciesSupport = arrayMethodHasSpeciesSupport$4; + + var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter'); + + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + // with adding support of @@species + $$7({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + filter: function filter(callbackfn /* , thisArg */) { + return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } + }); + + var anObject$3 = anObject$f; + var iteratorClose = iteratorClose$2; + + // call something on iterator step with safe closing on error + var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject$3(value)[0], value[1]) : fn(value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + }; + + var bind = functionBindContext; + var call$3 = functionCall; + var toObject$2 = toObject$a; + var callWithSafeIterationClosing = callWithSafeIterationClosing$1; + var isArrayIteratorMethod = isArrayIteratorMethod$2; + var isConstructor = isConstructor$4; + var lengthOfArrayLike = lengthOfArrayLike$9; + var createProperty = createProperty$4; + var getIterator = getIterator$2; + var getIteratorMethod = getIteratorMethod$3; + + var $Array = Array; + + // `Array.from` method implementation + // https://tc39.es/ecma262/#sec-array.from + var arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { + var O = toObject$2(arrayLike); + var IS_CONSTRUCTOR = isConstructor(this); + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined); + var iteratorMethod = getIteratorMethod(O); + var index = 0; + var length, result, step, iterator, next, value; + // if the target is not iterable or it's an array with the default iterator - use a simple case + if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) { + iterator = getIterator(O, iteratorMethod); + next = iterator.next; + result = IS_CONSTRUCTOR ? new this() : []; + for (;!(step = call$3(next, iterator)).done; index++) { + value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value; + createProperty(result, index, value); + } + } else { + length = lengthOfArrayLike(O); + result = IS_CONSTRUCTOR ? new this(length) : $Array(length); + for (;length > index; index++) { + value = mapping ? mapfn(O[index], index) : O[index]; + createProperty(result, index, value); + } + } + result.length = index; + return result; + }; + + var $$6 = _export; + var from = arrayFrom; + var checkCorrectnessOfIteration = checkCorrectnessOfIteration$3; + + var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { + // eslint-disable-next-line es/no-array-from -- required for testing + Array.from(iterable); + }); + + // `Array.from` method + // https://tc39.es/ecma262/#sec-array.from + $$6({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { + from: from + }); + + var _DomainCollection_instances, _DomainCollection_setSubDomainValues, _DomainCollection_extractValues, _DomainCollection_refreshKeys; + var DOMAIN_FORMAT = { + year: 'YYYY', + month: 'MMMM', + week: 'wo [week] YYYY', + xDay: 'Do MMM', + ghDay: 'Do MMM', + day: 'Do MMM', + hour: 'HH:00', + minute: 'HH:mm' + }; + var DomainCollection = /*#__PURE__*/function () { + function DomainCollection(dateHelper, interval, start, range) { + var excludeEnd = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false; + _classCallCheck(this, DomainCollection); + _DomainCollection_instances.add(this); + this.collection = new Map(); + this.dateHelper = dateHelper; + if (interval && start && range) { + var ts = this.dateHelper.intervals(interval, start, range, excludeEnd).map(function (d) { + return castArray(d); + }); + // @ts-ignore + this.collection = new Map(ts); + } + this.min = 0; + this.max = 0; + this.keys = []; + this.yankedDomains = []; + if (this.collection.size > 0) { + __classPrivateFieldGet(this, _DomainCollection_instances, "m", _DomainCollection_refreshKeys).call(this); + } + } + _createClass(DomainCollection, [{ + key: "has", + value: function has(key) { + return this.collection.has(key); + } + }, { + key: "get", + value: function get(key) { + return this.collection.get(key); + } + }, { + key: "forEach", + value: function forEach(callback) { + return this.collection.forEach(callback); + } + }, { + key: "at", + value: function at(index) { + return this.keys[index]; + } + }, { + key: "clamp", + value: function clamp(minDate, maxDate) { + var _this = this; + if (minDate && this.min < minDate) { + this.keys.filter(function (key) { + return key < minDate; + }).forEach(function (d) { + return _this.collection.delete(d); + }); + } + if (maxDate && this.max > maxDate) { + this.keys.filter(function (key) { + return key > maxDate; + }).forEach(function (d) { + return _this.collection.delete(d); + }); + } + __classPrivateFieldGet(this, _DomainCollection_instances, "m", _DomainCollection_refreshKeys).call(this); + return this; + } + }, { + key: "merge", + value: function merge(newCollection, limit, createValueCallback) { + var _this2 = this; + this.yankedDomains = []; + newCollection.keys.forEach(function (domainKey, index) { + if (_this2.has(domainKey)) { + return; + } + if (_this2.collection.size >= limit) { + var keyToRemove = _this2.max; + if (domainKey > _this2.max) { + keyToRemove = _this2.min; + } + if (keyToRemove && _this2.collection.delete(keyToRemove)) { + _this2.yankedDomains.push(keyToRemove); + } + } + _this2.collection.set(domainKey, createValueCallback(domainKey, index)); + __classPrivateFieldGet(_this2, _DomainCollection_instances, "m", _DomainCollection_refreshKeys).call(_this2); + }); + this.yankedDomains = this.yankedDomains.sort(function (a, b) { + return a - b; + }); + } + }, { + key: "slice", + value: function slice() { + var _this3 = this; + var limit = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; + var fromBeginning = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true; + if (this.keys.length > limit) { + var keysToDelete = fromBeginning ? this.keys.slice(0, -limit) : this.keys.slice(limit); + keysToDelete.forEach(function (key) { + _this3.collection.delete(key); + }); + __classPrivateFieldGet(this, _DomainCollection_instances, "m", _DomainCollection_refreshKeys).call(this); + } + return this; + } + }, { + key: "fill", + value: function fill(data, _ref, subDomainKeyExtractor) { + var _this4 = this; + var x = _ref.x, + y = _ref.y, + groupY = _ref.groupY, + defaultValue = _ref.defaultValue; + var groupedRecords = this.groupRecords(data, x, subDomainKeyExtractor); + this.keys.forEach(function (domainKey) { + var records = groupedRecords.get(domainKey) || {}; + __classPrivateFieldGet(_this4, _DomainCollection_instances, "m", _DomainCollection_setSubDomainValues).call(_this4, domainKey, records, y, groupY, defaultValue); + }); + } + }, { + key: "groupRecords", + value: function groupRecords(data, x, subDomainKeyExtractor) { + var _this5 = this; + var results = new Map(); + var validSubDomainTimestamp = new Map(); + this.keys.forEach(function (domainKey) { + _this5.get(domainKey).forEach(function (subDomain) { + validSubDomainTimestamp.set(subDomain.t, domainKey); + }); + }); + data.forEach(function (d) { + var timestamp = _this5.extractTimestamp(d, x, subDomainKeyExtractor); + if (validSubDomainTimestamp.has(timestamp)) { + var domainKey = validSubDomainTimestamp.get(timestamp); + var records = results.get(domainKey) || {}; + records[timestamp] || (records[timestamp] = []); + records[timestamp].push(d); + results.set(domainKey, records); + } + }); + return results; + } + // eslint-disable-next-line class-methods-use-this + }, { + key: "groupValues", + value: function groupValues(values, groupFn) { + var cleanedValues = values.filter(function (n) { + return n !== null; + }); + if (typeof groupFn === 'string') { + if (cleanedValues.every(function (n) { + return typeof n === 'number'; + })) { + switch (groupFn) { + case 'sum': + return cleanedValues.reduce(function (a, b) { + return a + b; + }, 0); + case 'count': + return cleanedValues.length; + case 'min': + return Math.min.apply(Math, _toConsumableArray(cleanedValues)) || null; + case 'max': + return Math.max.apply(Math, _toConsumableArray(cleanedValues)) || null; + case 'average': + return cleanedValues.length > 0 ? cleanedValues.reduce(function (a, b) { + return a + b; + }, 0) / cleanedValues.length : null; + default: + return null; + } + } + switch (groupFn) { + case 'count': + return cleanedValues.length; + default: + return null; + } + } else if (typeof groupFn === 'function') { + return groupFn(cleanedValues); + } + return null; + } + // eslint-disable-next-line class-methods-use-this + }, { + key: "extractTimestamp", + value: function extractTimestamp(datum, x, extractorFn) { + var timestamp = typeof x === 'function' ? x(datum) : datum[x]; + if (typeof timestamp === 'string') { + timestamp = +new Date(timestamp); + } + return extractorFn(timestamp); + } + }]); + return DomainCollection; + }(); + _DomainCollection_instances = new WeakSet(), _DomainCollection_setSubDomainValues = function _DomainCollection_setSubDomainValues(domainKey, records, y, groupY, defaultValue) { + var _this6 = this; + this.get(domainKey).forEach(function (subDomain, index) { + var value = defaultValue; + if (records.hasOwnProperty(subDomain.t)) { + value = _this6.groupValues(__classPrivateFieldGet(_this6, _DomainCollection_instances, "m", _DomainCollection_extractValues).call(_this6, records[subDomain.t], y), groupY); + } + _this6.get(domainKey)[index].v = value; + }); + }, _DomainCollection_extractValues = function _DomainCollection_extractValues(data, y) { + return data.map(function (d) { + return typeof y === 'function' ? y(d) : d[y]; + }); + }, _DomainCollection_refreshKeys = function _DomainCollection_refreshKeys() { + this.keys = Array.from(this.collection.keys()).map(function (d) { + return parseInt(d, 10); + }).sort(function (a, b) { + return a - b; + }); + var keys = this.keys; + // eslint-disable-next-line prefer-destructuring + this.min = keys[0]; + this.max = keys[keys.length - 1]; + return this.keys; + }; + + var _DomainLabelPainter_instances, _DomainLabelPainter_textVerticalAlign, _DomainLabelPainter_getX, _DomainLabelPainter_getY, _DomainLabelPainter_getDomainInsideWidth, _DomainLabelPainter_getDomainInsideHeight, _DomainLabelPainter_domainRotate; + var DEFAULT_SELECTOR$2 = '.ch-domain-text'; + var DomainLabelPainter = /*#__PURE__*/function () { + function DomainLabelPainter(calendar) { + _classCallCheck(this, DomainLabelPainter); + _DomainLabelPainter_instances.add(this); + this.calendar = calendar; + } + _createClass(DomainLabelPainter, [{ + key: "paint", + value: function paint(root) { + var _this = this; + var _this$calendar$option = this.calendar.options.options.domain, + label = _this$calendar$option.label, + type = _this$calendar$option.type; + var dateHelper = this.calendar.dateHelper; + var format = label.text; + if (format === null || format === '') { + return; + } + if (typeof format === 'undefined') { + format = DOMAIN_FORMAT[type]; + } + root.selectAll(DEFAULT_SELECTOR$2).data(function (d) { + return [d]; + }, function (d) { + return d; + }).join(function (enter) { + return enter.append('text').attr('class', DEFAULT_SELECTOR$2.slice(1)).attr('x', function (d) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getX).call(_this, d); + }).attr('y', function (d) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getY).call(_this, d); + }).attr('text-anchor', label.textAlign).attr('dominant-baseline', function () { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_textVerticalAlign).call(_this); + }).text(function (d, i, nodes) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + dateHelper.format(d, format, nodes[i]) + ); + }).call(function (selection) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_domainRotate).call(_this, selection); + }); + }, function (update) { + update.attr('x', function (d) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getX).call(_this, d); + }).attr('y', function (d) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getY).call(_this, d); + }).attr('text-anchor', label.textAlign).attr('dominant-baseline', function () { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_textVerticalAlign).call(_this); + }).text(function (d, i, nodes) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + dateHelper.format(d, format, nodes[i]) + ); + }).call(function (selection) { + return __classPrivateFieldGet(_this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_domainRotate).call(_this, selection); + }); + }); + } + }]); + return DomainLabelPainter; + }(); + _DomainLabelPainter_instances = new WeakSet(), _DomainLabelPainter_textVerticalAlign = function _DomainLabelPainter_textVerticalAlign() { + var _this$calendar$option2 = this.calendar.options.options.domain.label, + position = _this$calendar$option2.position, + rotate = _this$calendar$option2.rotate; + if (isVertical(position)) { + return 'middle'; + } + if (rotate === 'left' && position === 'left' || rotate === 'right' && position === 'right') { + return 'bottom'; + } + return 'hanging'; + }, _DomainLabelPainter_getX = function _DomainLabelPainter_getX(d) { + var _this$calendar$option3 = this.calendar.options.options.domain, + padding = _this$calendar$option3.padding, + _this$calendar$option4 = _this$calendar$option3.label, + position = _this$calendar$option4.position, + textAlign = _this$calendar$option4.textAlign, + offset = _this$calendar$option4.offset; + var domainHorizontalLabelWidth = this.calendar.options.options.x.domainHorizontalLabelWidth; + var x = padding[Position.LEFT]; + if (position === 'right') { + x += __classPrivateFieldGet(this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideWidth).call(this, d); + } + if (textAlign === 'middle') { + if (['top', 'bottom'].includes(position)) { + x += __classPrivateFieldGet(this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideWidth).call(this, d) / 2; + } else { + x += domainHorizontalLabelWidth / 2; + } + } + if (textAlign === 'end') { + if (isVertical(position)) { + x += __classPrivateFieldGet(this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideWidth).call(this, d); + } else { + x += domainHorizontalLabelWidth; + } + } + return x + offset.x; + }, _DomainLabelPainter_getY = function _DomainLabelPainter_getY(d) { + var _this$calendar$option5 = this.calendar.options.options, + _this$calendar$option6 = _this$calendar$option5.domain, + _this$calendar$option7 = _this$calendar$option6.label, + position = _this$calendar$option7.position, + offset = _this$calendar$option7.offset, + padding = _this$calendar$option6.padding, + x = _this$calendar$option5.x; + var y = padding[Position.TOP] + x.domainVerticalLabelHeight / 2; + if (position === 'bottom') { + y += __classPrivateFieldGet(this, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideHeight).call(this, d); + } + return y + offset.y; + }, _DomainLabelPainter_getDomainInsideWidth = function _DomainLabelPainter_getDomainInsideWidth(d) { + var _this$calendar$option8 = this.calendar.options.options, + padding = _this$calendar$option8.domain.padding, + domainHorizontalLabelWidth = _this$calendar$option8.x.domainHorizontalLabelWidth; + var coordinates = this.calendar.calendarPainter.domainsContainerPainter.domainPainter.coordinates; + return coordinates.get(d).inner_width - domainHorizontalLabelWidth - horizontalPadding(padding); + }, _DomainLabelPainter_getDomainInsideHeight = function _DomainLabelPainter_getDomainInsideHeight(d) { + var _this$calendar$option9 = this.calendar.options.options, + domainVerticalLabelHeight = _this$calendar$option9.x.domainVerticalLabelHeight, + padding = _this$calendar$option9.domain.padding; + var coordinates = this.calendar.calendarPainter.domainsContainerPainter.domainPainter.coordinates; + return coordinates.get(d).inner_height - domainVerticalLabelHeight - verticalPadding(padding); + }, _DomainLabelPainter_domainRotate = function _DomainLabelPainter_domainRotate(selection) { + var _this2 = this; + var _this$calendar$option10 = this.calendar.options.options, + _this$calendar$option11 = _this$calendar$option10.domain.label, + rotate = _this$calendar$option11.rotate, + textAlign = _this$calendar$option11.textAlign, + position = _this$calendar$option11.position, + x = _this$calendar$option10.x; + var labelWidth = x.domainHorizontalLabelWidth; + switch (rotate) { + // Rotating the text clockwise + case 'right': + selection.attr('transform', function (d) { + var domainWidth = __classPrivateFieldGet(_this2, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideWidth).call(_this2, d); + var domainHeight = __classPrivateFieldGet(_this2, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideHeight).call(_this2, d); + var s = ["rotate(90, ".concat(position === 'right' ? domainWidth : labelWidth, ", 0)")]; + switch (position) { + case 'right': + if (textAlign === 'middle') { + s.push("translate(".concat(domainHeight / 2 - labelWidth / 2, ")")); + } else if (textAlign === 'end') { + s.push("translate(".concat(domainHeight - labelWidth, ")")); + } + break; + case 'left': + if (textAlign === 'start') { + s.push("translate(".concat(labelWidth, ")")); + } else if (textAlign === 'middle') { + s.push("translate(".concat(labelWidth / 2 + domainHeight / 2, ")")); + } else if (textAlign === 'end') { + s.push("translate(".concat(domainHeight, ")")); + } + break; + } + return s.join(','); + }); + break; + // Rotating the text anticlockwise + case 'left': + selection.attr('transform', function (d) { + var domainWidth = __classPrivateFieldGet(_this2, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideWidth).call(_this2, d); + var domainHeight = __classPrivateFieldGet(_this2, _DomainLabelPainter_instances, "m", _DomainLabelPainter_getDomainInsideHeight).call(_this2, d); + var s = ["rotate(270, ".concat(position === 'right' ? domainWidth : labelWidth, ", 0)")]; + switch (position) { + case 'right': + if (textAlign === 'start') { + s.push("translate(-".concat(domainHeight, ")")); + } else if (textAlign === 'middle') { + s.push("translate(-".concat(domainHeight / 2 + labelWidth / 2, ")")); + } else if (textAlign === 'end') { + s.push("translate(-".concat(labelWidth, ")")); + } + break; + case 'left': + if (textAlign === 'start') { + s.push("translate(".concat(labelWidth - domainHeight, ")")); + } else if (textAlign === 'middle') { + s.push("translate(".concat(labelWidth / 2 - domainHeight / 2, ")")); + } + break; + } + return s.join(','); + }); + break; + } + }; + + // a string of all valid unicode whitespaces + var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + + '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + + var uncurryThis$8 = functionUncurryThis; + var requireObjectCoercible$3 = requireObjectCoercible$7; + var toString$5 = toString$9; + var whitespaces$1 = whitespaces$2; + + var replace$2 = uncurryThis$8(''.replace); + var ltrim = RegExp('^[' + whitespaces$1 + ']+'); + var rtrim = RegExp('(^|[^' + whitespaces$1 + '])[' + whitespaces$1 + ']+$'); + + // `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation + var createMethod$1 = function (TYPE) { + return function ($this) { + var string = toString$5(requireObjectCoercible$3($this)); + if (TYPE & 1) string = replace$2(string, ltrim, ''); + if (TYPE & 2) string = replace$2(string, rtrim, '$1'); + return string; + }; + }; + + var stringTrim = { + // `String.prototype.{ trimLeft, trimStart }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimstart + start: createMethod$1(1), + // `String.prototype.{ trimRight, trimEnd }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimend + end: createMethod$1(2), + // `String.prototype.trim` method + // https://tc39.es/ecma262/#sec-string.prototype.trim + trim: createMethod$1(3) + }; + + var PROPER_FUNCTION_NAME = functionName.PROPER; + var fails$7 = fails$u; + var whitespaces = whitespaces$2; + + var non = '\u200B\u0085\u180E'; + + // check that a method works with the correct list + // of whitespaces and has a correct name + var stringTrimForced = function (METHOD_NAME) { + return fails$7(function () { + return !!whitespaces[METHOD_NAME]() + || non[METHOD_NAME]() !== non + || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME); + }); + }; + + var $$5 = _export; + var $trim = stringTrim.trim; + var forcedStringTrimMethod = stringTrimForced; + + // `String.prototype.trim` method + // https://tc39.es/ecma262/#sec-string.prototype.trim + $$5({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, { + trim: function trim() { + return $trim(this); + } + }); + + var _SubDomainPainter_instances, _SubDomainPainter_setPositions, _SubDomainPainter_classname, _SubDomainPainter_appendText, _SubDomainPainter_getCoordinates, _SubDomainPainter_getX, _SubDomainPainter_getY; + var DEFAULT_SELECTOR$1 = '.ch-subdomain'; + var HIGHLIGHT_CLASSNAME = 'highlight'; + var SubDomainPainter = /*#__PURE__*/function () { + function SubDomainPainter(calendar) { + _classCallCheck(this, SubDomainPainter); + _SubDomainPainter_instances.add(this); + this.calendar = calendar; + this.root = null; + } + _createClass(SubDomainPainter, [{ + key: "paint", + value: function paint(root) { + var _this = this; + this.root = root || this.root; + var containerClassname = "".concat(DEFAULT_SELECTOR$1, "-container"); + var subDomainSvgGroup = this.root.selectAll(containerClassname).data(function (d) { + return [d]; + }, function (d) { + return d; + }).join(function (enter) { + return enter.append('svg').call(function (selection) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_setPositions).call(_this, selection); + }).attr('class', containerClassname.slice(1)); + }, function (update) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + update.call(function (selection) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_setPositions).call(_this, selection); + }) + ); + }); + var _this$calendar$option = this.calendar.options.options.subDomain, + radius = _this$calendar$option.radius, + width = _this$calendar$option.width, + height = _this$calendar$option.height, + sort = _this$calendar$option.sort; + var evt = this.calendar.eventEmitter; + subDomainSvgGroup.selectAll('g').data(function (d) { + var subDomainsCollection = _this.calendar.domainCollection.get(d); + if (sort === 'desc') { + var max = Math.max.apply(Math, _toConsumableArray(subDomainsCollection.map(function (s) { + return s.x; + }))); + subDomainsCollection.forEach(function (s, i) { + subDomainsCollection[i].x = Math.abs(s.x - max); + }); + } + return subDomainsCollection; + }).join(function (enter) { + return enter.append('g').call(function (selection) { + return selection.insert('rect').attr('class', function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_classname).call(_this, d.t, "".concat(DEFAULT_SELECTOR$1.slice(1), "-bg")) + ); + }).attr('width', width).attr('height', height).attr('x', function (d) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_getX).call(_this, d); + }).attr('y', function (d) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_getY).call(_this, d); + }).on('click', function (ev, d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + evt.emit('click', ev, d.t, d.v) + ); + }).on('mouseover', function (ev, d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + evt.emit('mouseover', ev, d.t, d.v) + ); + }).on('mouseout', function (ev, d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + evt.emit('mouseout', ev, d.t, d.v) + ); + }).attr('rx', radius > 0 ? radius : null).attr('ry', radius > 0 ? radius : null); + }).call(function (selection) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_appendText).call(_this, selection); + }); + }, function (update) { + return update.selectAll('rect').attr('class', function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_classname).call(_this, d.t, "".concat(DEFAULT_SELECTOR$1.slice(1), "-bg")) + ); + }).attr('width', width).attr('height', height).attr('x', function (d) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_getX).call(_this, d); + }).attr('y', function (d) { + return __classPrivateFieldGet(_this, _SubDomainPainter_instances, "m", _SubDomainPainter_getY).call(_this, d); + }).attr('rx', radius).attr('ry', radius); + }); + } + }]); + return SubDomainPainter; + }(); + _SubDomainPainter_instances = new WeakSet(), _SubDomainPainter_setPositions = function _SubDomainPainter_setPositions(selection) { + var options = this.calendar.options.options; + var _options$domain = options.domain, + padding = _options$domain.padding, + position = _options$domain.label.position; + selection.attr('x', function () { + var pos = padding[Position.LEFT]; + if (position === 'left') { + pos += options.x.domainHorizontalLabelWidth; + } + return pos; + }).attr('y', function () { + var pos = padding[Position.TOP]; + if (position === 'top') { + pos += options.x.domainVerticalLabelHeight; + } + return pos; + }); + }, _SubDomainPainter_classname = function _SubDomainPainter_classname(timestamp) { + var _this2 = this; + var _this$calendar$option2 = this.calendar.options.options, + highlight = _this$calendar$option2.date.highlight, + type = _this$calendar$option2.subDomain.type; + var classname = ''; + if (highlight.length > 0) { + highlight.forEach(function (d) { + var unitFn = _this2.calendar.templateCollection.get(type).extractUnit; + if (unitFn(+d) === unitFn(timestamp)) { + classname = HIGHLIGHT_CLASSNAME; + } + }); + } + for (var _len = arguments.length, otherClasses = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) { + otherClasses[_key - 1] = arguments[_key]; + } + return [classname].concat(otherClasses).join(' ').trim(); + }, _SubDomainPainter_appendText = function _SubDomainPainter_appendText(elem) { + var _this3 = this; + var _this$calendar$option3 = this.calendar.options.options.subDomain, + width = _this$calendar$option3.width, + height = _this$calendar$option3.height, + label = _this$calendar$option3.label; + if (!label) { + return null; + } + return elem.append('text').attr('class', function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + __classPrivateFieldGet(_this3, _SubDomainPainter_instances, "m", _SubDomainPainter_classname).call(_this3, d.t, "".concat(DEFAULT_SELECTOR$1.slice(1), "-text")) + ); + }).attr('x', function (d) { + return __classPrivateFieldGet(_this3, _SubDomainPainter_instances, "m", _SubDomainPainter_getX).call(_this3, d) + width / 2; + }).attr('y', function (d) { + return __classPrivateFieldGet(_this3, _SubDomainPainter_instances, "m", _SubDomainPainter_getY).call(_this3, d) + height / 2; + }).attr('text-anchor', 'middle').attr('dominant-baseline', 'central').text(function (d, i, nodes) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + _this3.calendar.dateHelper.format(d.t, label, d.v, nodes[i]) + ); + }); + }, _SubDomainPainter_getCoordinates = function _SubDomainPainter_getCoordinates(axis, d) { + var subDomain = this.calendar.options.options.subDomain; + return d[axis] * (subDomain[axis === 'x' ? 'width' : 'height'] + subDomain.gutter); + }, _SubDomainPainter_getX = function _SubDomainPainter_getX(d) { + return __classPrivateFieldGet(this, _SubDomainPainter_instances, "m", _SubDomainPainter_getCoordinates).call(this, 'x', d); + }, _SubDomainPainter_getY = function _SubDomainPainter_getY(d) { + return __classPrivateFieldGet(this, _SubDomainPainter_instances, "m", _SubDomainPainter_getCoordinates).call(this, 'y', d); + }; + + var _DomainsContainerPainter_instances, _DomainsContainerPainter_startAnimation, _DomainsContainerPainter_endAnimation, _DomainsContainerPainter_recomputeDimensions; + var BASE_SELECTOR = '.ch-domain-container'; + var TRANSITION_CLASSNAME = 'in-transition'; + var DomainsContainerPainter = /*#__PURE__*/function () { + function DomainsContainerPainter(calendar) { + _classCallCheck(this, DomainsContainerPainter); + _DomainsContainerPainter_instances.add(this); + this.calendar = calendar; + this.domainPainter = new DomainPainter(calendar); + this.subDomainPainter = new SubDomainPainter(calendar); + this.domainLabelPainter = new DomainLabelPainter(calendar); + this.dimensions = { + width: 0, + height: 0 + }; + this.transitionsQueueCount = 0; + } + _createClass(DomainsContainerPainter, [{ + key: "setup", + value: function setup() { + this.root = this.calendar.calendarPainter.root.attr('x', 0).attr('y', 0).append('svg').attr('class', BASE_SELECTOR.slice(1)).append('svg').attr('class', "".concat(BASE_SELECTOR.slice(1), "-animation-wrapper")); + } + }, { + key: "paint", + value: function paint(scrollDirection) { + var _this = this; + __classPrivateFieldGet(this, _DomainsContainerPainter_instances, "m", _DomainsContainerPainter_startAnimation).call(this); + var result = this.domainPainter.paint(scrollDirection, this.root); + this.subDomainPainter.paint(this.domainPainter.root); + this.domainLabelPainter.paint(this.domainPainter.root); + __classPrivateFieldGet(this, _DomainsContainerPainter_instances, "m", _DomainsContainerPainter_recomputeDimensions).call(this); + Promise.allSettled(result).then(function () { + __classPrivateFieldGet(_this, _DomainsContainerPainter_instances, "m", _DomainsContainerPainter_endAnimation).call(_this); + }); + return result; + } + }, { + key: "updatePosition", + value: function updatePosition() { + var _a; + if (!((_a = this.root) === null || _a === void 0 ? void 0 : _a.node())) { + return Promise.resolve(); + } + var animationDuration = this.calendar.options.options.animationDuration; + var topHeight = this.calendar.pluginManager.getHeightFromPosition('top'); + var leftWidth = this.calendar.pluginManager.getWidthFromPosition('left'); + return [d3Selection.select(this.root.node().parentNode).transition().duration(animationDuration).call(function (selection) { + selection.attr('x', leftWidth).attr('y', topHeight); + }).end()]; + } + }, { + key: "width", + value: function width() { + return this.dimensions.width; + } + }, { + key: "height", + value: function height() { + return this.dimensions.height; + } + }, { + key: "destroy", + value: function destroy() { + __classPrivateFieldGet(this, _DomainsContainerPainter_instances, "m", _DomainsContainerPainter_startAnimation).call(this); + return Promise.resolve(); + } + }]); + return DomainsContainerPainter; + }(); + _DomainsContainerPainter_instances = new WeakSet(), _DomainsContainerPainter_startAnimation = function _DomainsContainerPainter_startAnimation() { + var _a; + if ((_a = this.root) === null || _a === void 0 ? void 0 : _a.node()) { + this.transitionsQueueCount += 1; + d3Selection.select(this.root.node().parentNode).classed(TRANSITION_CLASSNAME, true); + } + }, _DomainsContainerPainter_endAnimation = function _DomainsContainerPainter_endAnimation() { + var _a; + if ((_a = this.root) === null || _a === void 0 ? void 0 : _a.node()) { + this.transitionsQueueCount -= 1; + if (this.transitionsQueueCount === 0) { + d3Selection.select(this.root.node().parentNode).classed(TRANSITION_CLASSNAME, false); + } + } + }, _DomainsContainerPainter_recomputeDimensions = function _DomainsContainerPainter_recomputeDimensions() { + var _this$calendar$option = this.calendar.options.options, + animationDuration = _this$calendar$option.animationDuration, + verticalOrientation = _this$calendar$option.verticalOrientation, + gutter = _this$calendar$option.domain.gutter; + var domainsDimensions = this.domainPainter.dimensions; + this.dimensions = { + width: domainsDimensions.width - (verticalOrientation ? 0 : gutter), + height: domainsDimensions.height - (!verticalOrientation ? 0 : gutter) + }; + this.root.transition().duration(animationDuration).attr('width', this.dimensions.width).attr('height', this.dimensions.height); + }; + + var PluginPainter = /*#__PURE__*/function () { + function PluginPainter(calendar) { + _classCallCheck(this, PluginPainter); + this.calendar = calendar; + } + _createClass(PluginPainter, [{ + key: "paint", + value: function paint() { + var promises = []; + promises = promises.concat(this.calendar.pluginManager.paintAll()); + promises = promises.concat(this.setPluginsPosition()); + return promises; + } + }, { + key: "setPluginsPosition", + value: function setPluginsPosition() { + var pluginManager = this.calendar.pluginManager; + var animationDuration = this.calendar.options.options.animationDuration; + var domainsContainerPainter = this.calendar.calendarPainter.domainsContainerPainter; + var top = pluginManager.getFromPosition('top'); + var right = pluginManager.getFromPosition('right'); + var bottom = pluginManager.getFromPosition('bottom'); + var left = pluginManager.getFromPosition('left'); + var topHeight = pluginManager.getHeightFromPosition('top'); + var leftWidth = pluginManager.getWidthFromPosition('left'); + var promises = []; + var topOffset = 0; + top.forEach(function (plugin) { + promises.push(plugin.root.transition().duration(animationDuration).attr('y', topOffset).attr('x', leftWidth).end()); + topOffset += plugin.options.dimensions.height; + }); + var leftOffset = 0; + left.forEach(function (plugin) { + promises.push(plugin.root.transition().duration(animationDuration).attr('x', leftOffset).attr('y', topHeight).end()); + leftOffset += plugin.options.dimensions.width; + }); + bottom.forEach(function (plugin) { + promises.push(plugin.root.transition().duration(animationDuration).attr('x', leftWidth).attr('y', topHeight + domainsContainerPainter.height()).end()); + }); + leftOffset += domainsContainerPainter.width(); + right.forEach(function (plugin) { + promises.push(plugin.root.transition().duration(animationDuration).attr('x', leftOffset).attr('y', topHeight).end()); + leftOffset += plugin.options.dimensions.width; + }); + return promises; + } + }, { + key: "insideWidth", + value: function insideWidth() { + return this.calendar.pluginManager.getWidthFromPosition('left') + this.calendar.pluginManager.getWidthFromPosition('right'); + } + }, { + key: "insideHeight", + value: function insideHeight() { + return this.calendar.pluginManager.getHeightFromPosition('top') + this.calendar.pluginManager.getHeightFromPosition('bottom'); + } + }]); + return PluginPainter; + }(); + + var _CalendarPainter_instances, _CalendarPainter_getHeight, _CalendarPainter_getWidth, _CalendarPainter_resize; + var DEFAULT_SELECTOR = '.ch-container'; + var CalendarPainter = /*#__PURE__*/function () { + function CalendarPainter(calendar) { + _classCallCheck(this, CalendarPainter); + _CalendarPainter_instances.add(this); + this.calendar = calendar; + this.dimensions = { + width: 0, + height: 0 + }; + this.root = null; + this.domainsContainerPainter = new DomainsContainerPainter(calendar); + this.pluginPainter = new PluginPainter(calendar); + } + _createClass(CalendarPainter, [{ + key: "setup", + value: function setup() { + var _this$calendar$option = this.calendar.options.options, + itemSelector = _this$calendar$option.itemSelector, + theme = _this$calendar$option.theme; + if (!this.root) { + this.root = d3Selection.select(itemSelector).append('svg').attr('data-theme', theme).attr('class', DEFAULT_SELECTOR.slice(1)); + this.domainsContainerPainter.setup(); + } + this.calendar.pluginManager.setupAll(); + return true; + } + }, { + key: "paint", + value: function paint() { + var navigationDir = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : ScrollDirection.SCROLL_NONE; + var transitions = this.domainsContainerPainter.paint(navigationDir).concat(this.pluginPainter.paint()).concat(this.domainsContainerPainter.updatePosition()); + __classPrivateFieldGet(this, _CalendarPainter_instances, "m", _CalendarPainter_resize).call(this); + return Promise.allSettled(transitions); + } + }, { + key: "destroy", + value: function destroy() { + var result = this.calendar.pluginManager.destroyAll().concat(this.domainsContainerPainter.destroy()); + if (!this.root) { + return Promise.allSettled(result); + } + result.push(this.root.transition().duration(this.calendar.options.options.animationDuration).attr('width', 0).attr('height', 0).remove().end()); + return Promise.allSettled(result); + } + }]); + return CalendarPainter; + }(); + _CalendarPainter_instances = new WeakSet(), _CalendarPainter_getHeight = function _CalendarPainter_getHeight() { + return this.domainsContainerPainter.height() + this.pluginPainter.insideHeight(); + }, _CalendarPainter_getWidth = function _CalendarPainter_getWidth() { + return this.domainsContainerPainter.width() + this.pluginPainter.insideWidth(); + }, _CalendarPainter_resize = function _CalendarPainter_resize() { + var options = this.calendar.options.options; + var newWidth = __classPrivateFieldGet(this, _CalendarPainter_instances, "m", _CalendarPainter_getWidth).call(this); + var newHeight = __classPrivateFieldGet(this, _CalendarPainter_instances, "m", _CalendarPainter_getHeight).call(this); + this.root.transition().duration(options.animationDuration).attr('width', newWidth).attr('height', newHeight); + if (newWidth !== this.dimensions.width || newHeight !== this.dimensions.height) { + this.calendar.eventEmitter.emit('resize', newWidth, newHeight, this.dimensions.width, this.dimensions.height); + } + this.dimensions = { + width: newWidth, + height: newHeight + }; + }; + + /** Detect free variable `global` from Node.js. */ + var freeGlobal = typeof global == 'object' && global && global.Object === Object && global; + + var freeGlobal$1 = freeGlobal; + + /** Detect free variable `self`. */ + var freeSelf = typeof self == 'object' && self && self.Object === Object && self; + + /** Used as a reference to the global object. */ + var root = freeGlobal$1 || freeSelf || Function('return this')(); + + var root$1 = root; + + /** Built-in value references. */ + var Symbol$1 = root$1.Symbol; + + var Symbol$2 = Symbol$1; + + /** Used for built-in method references. */ + var objectProto$f = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$c = objectProto$f.hasOwnProperty; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var nativeObjectToString$1 = objectProto$f.toString; + + /** Built-in value references. */ + var symToStringTag$1 = Symbol$2 ? Symbol$2.toStringTag : undefined; + + /** + * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the raw `toStringTag`. + */ + function getRawTag(value) { + var isOwn = hasOwnProperty$c.call(value, symToStringTag$1), + tag = value[symToStringTag$1]; + + try { + value[symToStringTag$1] = undefined; + var unmasked = true; + } catch (e) {} + + var result = nativeObjectToString$1.call(value); + if (unmasked) { + if (isOwn) { + value[symToStringTag$1] = tag; + } else { + delete value[symToStringTag$1]; + } + } + return result; + } + + /** Used for built-in method references. */ + var objectProto$e = Object.prototype; + + /** + * Used to resolve the + * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring) + * of values. + */ + var nativeObjectToString = objectProto$e.toString; + + /** + * Converts `value` to a string using `Object.prototype.toString`. + * + * @private + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + */ + function objectToString$1(value) { + return nativeObjectToString.call(value); + } + + /** `Object#toString` result references. */ + var nullTag = '[object Null]', + undefinedTag = '[object Undefined]'; + + /** Built-in value references. */ + var symToStringTag = Symbol$2 ? Symbol$2.toStringTag : undefined; + + /** + * The base implementation of `getTag` without fallbacks for buggy environments. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + function baseGetTag(value) { + if (value == null) { + return value === undefined ? undefinedTag : nullTag; + } + return (symToStringTag && symToStringTag in Object(value)) + ? getRawTag(value) + : objectToString$1(value); + } + + /** + * Checks if `value` is the + * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types) + * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`) + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an object, else `false`. + * @example + * + * _.isObject({}); + * // => true + * + * _.isObject([1, 2, 3]); + * // => true + * + * _.isObject(_.noop); + * // => true + * + * _.isObject(null); + * // => false + */ + function isObject$2(value) { + var type = typeof value; + return value != null && (type == 'object' || type == 'function'); + } + + /** `Object#toString` result references. */ + var asyncTag = '[object AsyncFunction]', + funcTag$1 = '[object Function]', + genTag = '[object GeneratorFunction]', + proxyTag = '[object Proxy]'; + + /** + * Checks if `value` is classified as a `Function` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a function, else `false`. + * @example + * + * _.isFunction(_); + * // => true + * + * _.isFunction(/abc/); + * // => false + */ + function isFunction(value) { + if (!isObject$2(value)) { + return false; + } + // The use of `Object#toString` avoids issues with the `typeof` operator + // in Safari 9 which returns 'object' for typed arrays and other constructors. + var tag = baseGetTag(value); + return tag == funcTag$1 || tag == genTag || tag == asyncTag || tag == proxyTag; + } + + var $$4 = _export; + var toObject$1 = toObject$a; + var nativeKeys$2 = objectKeys$3; + var fails$6 = fails$u; + + var FAILS_ON_PRIMITIVES = fails$6(function () { nativeKeys$2(1); }); + + // `Object.keys` method + // https://tc39.es/ecma262/#sec-object.keys + $$4({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { + keys: function keys(it) { + return nativeKeys$2(toObject$1(it)); + } + }); + + var isObject$1 = isObject$j; + var classof$1 = classofRaw$2; + var wellKnownSymbol$3 = wellKnownSymbol$m; + + var MATCH$1 = wellKnownSymbol$3('match'); + + // `IsRegExp` abstract operation + // https://tc39.es/ecma262/#sec-isregexp + var isRegexp = function (it) { + var isRegExp; + return isObject$1(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof$1(it) === 'RegExp'); + }; + + var isRegExp = isRegexp; + + var $TypeError$1 = TypeError; + + var notARegexp = function (it) { + if (isRegExp(it)) { + throw new $TypeError$1("The method doesn't accept regular expressions"); + } return it; + }; + + var wellKnownSymbol$2 = wellKnownSymbol$m; + + var MATCH = wellKnownSymbol$2('match'); + + var correctIsRegexpLogic = function (METHOD_NAME) { + var regexp = /./; + try { + '/./'[METHOD_NAME](regexp); + } catch (error1) { + try { + regexp[MATCH] = false; + return '/./'[METHOD_NAME](regexp); + } catch (error2) { /* empty */ } + } return false; + }; + + var $$3 = _export; + var uncurryThis$7 = functionUncurryThisClause; + var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + var toLength$1 = toLength$3; + var toString$4 = toString$9; + var notARegExp$1 = notARegexp; + var requireObjectCoercible$2 = requireObjectCoercible$7; + var correctIsRegExpLogic$1 = correctIsRegexpLogic; + + // eslint-disable-next-line es/no-string-prototype-startswith -- safe + var nativeStartsWith = uncurryThis$7(''.startsWith); + var stringSlice$3 = uncurryThis$7(''.slice); + var min$1 = Math.min; + + var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic$1('startsWith'); + // https://github.com/zloirock/core-js/pull/702 + var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () { + var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith'); + return descriptor && !descriptor.writable; + }(); + + // `String.prototype.startsWith` method + // https://tc39.es/ecma262/#sec-string.prototype.startswith + $$3({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, { + startsWith: function startsWith(searchString /* , position = 0 */) { + var that = toString$4(requireObjectCoercible$2(this)); + notARegExp$1(searchString); + var index = toLength$1(min$1(arguments.length > 1 ? arguments[1] : undefined, that.length)); + var search = toString$4(searchString); + return nativeStartsWith + ? nativeStartsWith(that, search, index) + : stringSlice$3(that, index, index + search.length) === search; + } + }); + + var DESCRIPTORS$1 = descriptors; + var fails$5 = fails$u; + var uncurryThis$6 = functionUncurryThis; + var objectGetPrototypeOf = objectGetPrototypeOf$1; + var objectKeys = objectKeys$3; + var toIndexedObject = toIndexedObject$9; + var $propertyIsEnumerable = objectPropertyIsEnumerable.f; + + var propertyIsEnumerable$2 = uncurryThis$6($propertyIsEnumerable); + var push$1 = uncurryThis$6([].push); + + // in some IE versions, `propertyIsEnumerable` returns incorrect result on integer keys + // of `null` prototype objects + var IE_BUG = DESCRIPTORS$1 && fails$5(function () { + // eslint-disable-next-line es/no-object-create -- safe + var O = Object.create(null); + O[2] = 2; + return !propertyIsEnumerable$2(O, 2); + }); + + // `Object.{ entries, values }` methods implementation + var createMethod = function (TO_ENTRIES) { + return function (it) { + var O = toIndexedObject(it); + var keys = objectKeys(O); + var IE_WORKAROUND = IE_BUG && objectGetPrototypeOf(O) === null; + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!DESCRIPTORS$1 || (IE_WORKAROUND ? key in O : propertyIsEnumerable$2(O, key))) { + push$1(result, TO_ENTRIES ? [key, O[key]] : O[key]); + } + } + return result; + }; + }; + + var objectToArray = { + // `Object.entries` method + // https://tc39.es/ecma262/#sec-object.entries + entries: createMethod(true), + // `Object.values` method + // https://tc39.es/ecma262/#sec-object.values + values: createMethod(false) + }; + + var $$2 = _export; + var $entries = objectToArray.entries; + + // `Object.entries` method + // https://tc39.es/ecma262/#sec-object.entries + $$2({ target: 'Object', stat: true }, { + entries: function entries(O) { + return $entries(O); + } + }); + + function defined(x) { + return x != null && !Number.isNaN(x); + } + + function ascendingDefined(a, b) { + return +defined(b) - +defined(a) || d3.ascending(a, b); + } + + function finite(x) { + return isFinite(x) ? x : NaN; + } + + function positive(x) { + return x > 0 && isFinite(x) ? x : NaN; + } + + function negative(x) { + return x < 0 && isFinite(x) ? x : NaN; + } + + const re = /^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/; + + function parse(string, fallback) { + if (!re.test(string += "")) return typeof fallback === "function" ? fallback(string) : fallback; + return new Date(string); + } + + const timeIntervals = new Map([ + ["second", d3.timeSecond], + ["minute", d3.timeMinute], + ["hour", d3.timeHour], + ["day", d3.timeDay], + ["week", d3.timeWeek], + ["month", d3.timeMonth], + ["quarter", d3.timeMonth.every(3)], + ["half", d3.timeMonth.every(6)], + ["year", d3.timeYear], + ["monday", d3.timeMonday], + ["tuesday", d3.timeTuesday], + ["wednesday", d3.timeWednesday], + ["thursday", d3.timeThursday], + ["friday", d3.timeFriday], + ["saturday", d3.timeSaturday], + ["sunday", d3.timeSunday] + ]); + + const utcIntervals = new Map([ + ["second", d3.utcSecond], + ["minute", d3.utcMinute], + ["hour", d3.utcHour], + ["day", d3.utcDay], + ["week", d3.utcWeek], + ["month", d3.utcMonth], + ["quarter", d3.utcMonth.every(3)], + ["half", d3.utcMonth.every(6)], + ["year", d3.utcYear], + ["monday", d3.utcMonday], + ["tuesday", d3.utcTuesday], + ["wednesday", d3.utcWednesday], + ["thursday", d3.utcThursday], + ["friday", d3.utcFriday], + ["saturday", d3.utcSaturday], + ["sunday", d3.utcSunday] + ]); + + function maybeTimeInterval(interval) { + const i = timeIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; + } + + function maybeUtcInterval(interval) { + const i = utcIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; + } + + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + const TypedArray = Object.getPrototypeOf(Uint8Array); + const objectToString = Object.prototype.toString; + const constant$1 = (x) => () => x; + + // If the values are specified as a typed array, no coercion is required. + function coerceNumbers(values) { + return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array); + } + + // Unlike Mark’s number, here we want to convert null and undefined to NaN since + // the result will be stored in a Float64Array and we don’t want null to be + // coerced to zero. We use Number instead of unary + to allow BigInt coercion. + function coerceNumber(x) { + return x == null ? NaN : Number(x); + } + + function coerceDates(values) { + return map(values, coerceDate); + } + + // When coercing strings to dates, we only want to allow the ISO 8601 format + // since the built-in string parsing of the Date constructor varies across + // browsers. (In the future, this could be made more liberal if desired, though + // it is still generally preferable to do date parsing yourself explicitly, + // rather than rely on Plot.) Any non-string values are coerced to number first + // and treated as milliseconds since UNIX epoch. + function coerceDate(x) { + return x instanceof Date && !isNaN(x) + ? x + : typeof x === "string" + ? parse(x) + : x == null || isNaN((x = +x)) + ? undefined + : new Date(x); + } + + // Promotes the specified data to an array as needed. + function arrayify(data) { + return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data); + } + + // An optimization of type.from(values, f): if the given values are already an + // instanceof the desired array type, the faster values.map method is used. + function map(values, f, type = Array) { + return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f); + } + + // An optimization of type.from(values): if the given values are already an + // instanceof the desired array type, the faster values.slice method is used. + function slice(values, type = Array) { + return values instanceof type ? values.slice() : type.from(values); + } + + // Disambiguates an options object (e.g., {y: "x2"}) from a primitive value. + function isObject(option) { + return option?.toString === objectToString; + } + + // Disambiguates a scale options object (e.g., {color: {type: "linear"}}) from + // some other option (e.g., {color: "red"}). When creating standalone legends, + // this is used to test whether a scale is defined; this should be consistent + // with inferScaleType when there are no channels associated with the scale, and + // if this returns true, then normalizeScale must return non-null. + function isScaleOptions(option) { + return isObject(option) && (option.type !== undefined || option.domain !== undefined); + } + + // If interval is not nullish, converts interval shorthand such as a number (for + // multiples) or a time interval name (such as “day”) to a {floor, offset, + // range} object similar to a D3 time interval. + function maybeInterval(interval, type) { + if (interval == null) return; + if (typeof interval === "number") { + if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval; + const n = Math.abs(interval); + return interval < 0 + ? { + floor: (d) => Math.floor(d * n) / n, + offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity + range: (lo, hi) => d3.range(Math.ceil(lo * n), hi * n).map((x) => x / n) + } + : { + floor: (d) => Math.floor(d / n) * n, + offset: (d) => d + n, // note: no optional step for simplicity + range: (lo, hi) => d3.range(Math.ceil(lo / n), hi / n).map((x) => x * n) + }; + } + if (typeof interval === "string") return (type === "time" ? maybeTimeInterval : maybeUtcInterval)(interval); + if (typeof interval.floor !== "function") throw new Error("invalid interval; missing floor method"); + if (typeof interval.offset !== "function") throw new Error("invalid interval; missing offset method"); + return interval; + } + + // Like maybeInterval, but requires a range method too. + function maybeRangeInterval(interval, type) { + interval = maybeInterval(interval, type); + if (interval && typeof interval.range !== "function") throw new Error("invalid interval: missing range method"); + return interval; + } + + // Like maybeRangeInterval, but requires a ceil method too. + function maybeNiceInterval(interval, type) { + interval = maybeRangeInterval(interval, type); + if (interval && typeof interval.ceil !== "function") throw new Error("invalid interval: missing ceil method"); + return interval; + } + + function isOrdinal(values) { + for (const value of values) { + if (value == null) continue; + const type = typeof value; + return type === "string" || type === "boolean"; + } + } + + function isTemporal(values) { + for (const value of values) { + if (value == null) continue; + return value instanceof Date; + } + } + + // Are these strings that might represent dates? This is stricter than ISO 8601 + // because we want to ignore false positives on numbers; for example, the string + // "1192" is more likely to represent a number than a date even though it is + // valid ISO 8601 representing 1192-01-01. + function isTemporalString(values) { + for (const value of values) { + if (value == null) continue; + return typeof value === "string" && isNaN(value) && parse(value); + } + } + + // Are these strings that might represent numbers? This is stricter than + // coercion because we want to ignore false positives on e.g. empty strings. + function isNumericString(values) { + for (const value of values) { + if (value == null) continue; + if (typeof value !== "string") return false; + if (!value.trim()) continue; + return !isNaN(value); + } + } + + function isNoneish(value) { + return value == null || isNone(value); + } + + function isNone(value) { + return /^\s*none\s*$/i.test(value); + } + + // Like a sort comparator, returns a positive value if the given array of values + // is in ascending order, a negative value if the values are in descending + // order. Assumes monotonicity; only tests the first and last values. + function orderof(values) { + if (values == null) return; + const first = values[0]; + const last = values[values.length - 1]; + return d3.descending(first, last); + } + + // Positional scales have associated axes, and for ordinal data, a point or band + // scale is used instead of an ordinal scale. + const position = Symbol("position"); + + // Color scales default to the turbo interpolator for quantitative data, and to + // the Tableau10 scheme for ordinal data. Color scales may also have an + // associated legend. + const color = Symbol("color"); + + // Radius scales default to the sqrt type, have a default range of [0, 3], and a + // default domain from 0 to the median first quartile of associated channels. + const radius = Symbol("radius"); + + // Length scales default to the linear type, have a default range of [0, 12], + // and a default domain from 0 to the median median of associated channels. + const length = Symbol("length"); + + // Opacity scales have a default range of [0, 1], and a default domain from 0 to + // the maximum value of associated channels. + const opacity = Symbol("opacity"); + + // Symbol scales have a default range of categorical symbols. + const symbol = Symbol("symbol"); + + // TODO Rather than hard-coding the list of known scale names, collect the names + // and categories for each plot specification, so that custom marks can register + // custom scales. + const registry = new Map([ + ["x", position], + ["y", position], + ["fx", position], + ["fy", position], + ["r", radius], + ["color", color], + ["opacity", opacity], + ["symbol", symbol], + ["length", length] + ]); + + const sqrt3 = Math.sqrt(3); + const sqrt4_3 = 2 / sqrt3; + + const symbolHexagon = { + draw(context, size) { + const rx = Math.sqrt(size / Math.PI), + ry = rx * sqrt4_3, + hy = ry / 2; + context.moveTo(0, ry); + context.lineTo(rx, hy); + context.lineTo(rx, -hy); + context.lineTo(0, -ry); + context.lineTo(-rx, -hy); + context.lineTo(-rx, hy); + context.closePath(); + } + }; + + const symbols = new Map([ + ["asterisk", d3.symbolAsterisk], + ["circle", d3.symbolCircle], + ["cross", d3.symbolCross], + ["diamond", d3.symbolDiamond], + ["diamond2", d3.symbolDiamond2], + ["hexagon", symbolHexagon], + ["plus", d3.symbolPlus], + ["square", d3.symbolSquare], + ["square2", d3.symbolSquare2], + ["star", d3.symbolStar], + ["times", d3.symbolTimes], + ["triangle", d3.symbolTriangle], + ["triangle2", d3.symbolTriangle2], + ["wye", d3.symbolWye] + ]); + + function isSymbolObject(value) { + return value && typeof value.draw === "function"; + } + + function maybeSymbol(symbol) { + if (symbol == null || isSymbolObject(symbol)) return symbol; + const value = symbols.get(`${symbol}`.toLowerCase()); + if (value) return value; + throw new Error(`invalid symbol: ${symbol}`); + } + + function warn(message) { + console.warn(message); + } + + const ordinalSchemes = new Map([ + // categorical + ["accent", d3.schemeAccent], + ["category10", d3.schemeCategory10], + ["dark2", d3.schemeDark2], + ["paired", d3.schemePaired], + ["pastel1", d3.schemePastel1], + ["pastel2", d3.schemePastel2], + ["set1", d3.schemeSet1], + ["set2", d3.schemeSet2], + ["set3", d3.schemeSet3], + ["tableau10", d3.schemeTableau10], + + // diverging + ["brbg", scheme11(d3.schemeBrBG, d3.interpolateBrBG)], + ["prgn", scheme11(d3.schemePRGn, d3.interpolatePRGn)], + ["piyg", scheme11(d3.schemePiYG, d3.interpolatePiYG)], + ["puor", scheme11(d3.schemePuOr, d3.interpolatePuOr)], + ["rdbu", scheme11(d3.schemeRdBu, d3.interpolateRdBu)], + ["rdgy", scheme11(d3.schemeRdGy, d3.interpolateRdGy)], + ["rdylbu", scheme11(d3.schemeRdYlBu, d3.interpolateRdYlBu)], + ["rdylgn", scheme11(d3.schemeRdYlGn, d3.interpolateRdYlGn)], + ["spectral", scheme11(d3.schemeSpectral, d3.interpolateSpectral)], + + // reversed diverging (for temperature data) + ["burd", scheme11r(d3.schemeRdBu, d3.interpolateRdBu)], + ["buylrd", scheme11r(d3.schemeRdYlBu, d3.interpolateRdYlBu)], + + // sequential (single-hue) + ["blues", scheme9(d3.schemeBlues, d3.interpolateBlues)], + ["greens", scheme9(d3.schemeGreens, d3.interpolateGreens)], + ["greys", scheme9(d3.schemeGreys, d3.interpolateGreys)], + ["oranges", scheme9(d3.schemeOranges, d3.interpolateOranges)], + ["purples", scheme9(d3.schemePurples, d3.interpolatePurples)], + ["reds", scheme9(d3.schemeReds, d3.interpolateReds)], + + // sequential (multi-hue) + ["turbo", schemei(d3.interpolateTurbo)], + ["viridis", schemei(d3.interpolateViridis)], + ["magma", schemei(d3.interpolateMagma)], + ["inferno", schemei(d3.interpolateInferno)], + ["plasma", schemei(d3.interpolatePlasma)], + ["cividis", schemei(d3.interpolateCividis)], + ["cubehelix", schemei(d3.interpolateCubehelixDefault)], + ["warm", schemei(d3.interpolateWarm)], + ["cool", schemei(d3.interpolateCool)], + ["bugn", scheme9(d3.schemeBuGn, d3.interpolateBuGn)], + ["bupu", scheme9(d3.schemeBuPu, d3.interpolateBuPu)], + ["gnbu", scheme9(d3.schemeGnBu, d3.interpolateGnBu)], + ["orrd", scheme9(d3.schemeOrRd, d3.interpolateOrRd)], + ["pubu", scheme9(d3.schemePuBu, d3.interpolatePuBu)], + ["pubugn", scheme9(d3.schemePuBuGn, d3.interpolatePuBuGn)], + ["purd", scheme9(d3.schemePuRd, d3.interpolatePuRd)], + ["rdpu", scheme9(d3.schemeRdPu, d3.interpolateRdPu)], + ["ylgn", scheme9(d3.schemeYlGn, d3.interpolateYlGn)], + ["ylgnbu", scheme9(d3.schemeYlGnBu, d3.interpolateYlGnBu)], + ["ylorbr", scheme9(d3.schemeYlOrBr, d3.interpolateYlOrBr)], + ["ylorrd", scheme9(d3.schemeYlOrRd, d3.interpolateYlOrRd)], + + // cyclical + ["rainbow", schemeicyclical(d3.interpolateRainbow)], + ["sinebow", schemeicyclical(d3.interpolateSinebow)] + ]); + + function scheme9(scheme, interpolate) { + return ({length: n}) => { + if (n === 1) return [scheme[3][1]]; // favor midpoint + if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker + n = Math.max(3, Math.floor(n)); + return n > 9 ? d3.quantize(interpolate, n) : scheme[n]; + }; + } + + function scheme11(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? d3.quantize(interpolate, n) : scheme[n]; + }; + } + + function scheme11r(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? d3.quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse(); + }; + } + + function schemei(interpolate) { + return ({length: n}) => d3.quantize(interpolate, Math.max(2, Math.floor(n))); + } + + function schemeicyclical(interpolate) { + return ({length: n}) => d3.quantize(interpolate, Math.floor(n) + 1).slice(0, -1); + } + + function ordinalScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`); + return ordinalSchemes.get(s); + } + + function ordinalRange(scheme, length) { + const s = ordinalScheme(scheme); + const r = typeof s === "function" ? s({length}) : s; + return r.length !== length ? r.slice(0, length) : r; + } + + // If the specified domain contains only booleans (ignoring null and undefined), + // returns a corresponding range where false is mapped to the low color and true + // is mapped to the high color of the specified scheme. + function maybeBooleanRange(domain, scheme = "greys") { + const range = new Set(); + const [f, t] = ordinalRange(scheme, 2); + for (const value of domain) { + if (value == null) continue; + if (value === true) range.add(t); + else if (value === false) range.add(f); + else return; + } + return [...range]; + } + + const quantitativeSchemes = new Map([ + // diverging + ["brbg", d3.interpolateBrBG], + ["prgn", d3.interpolatePRGn], + ["piyg", d3.interpolatePiYG], + ["puor", d3.interpolatePuOr], + ["rdbu", d3.interpolateRdBu], + ["rdgy", d3.interpolateRdGy], + ["rdylbu", d3.interpolateRdYlBu], + ["rdylgn", d3.interpolateRdYlGn], + ["spectral", d3.interpolateSpectral], + + // reversed diverging (for temperature data) + ["burd", (t) => d3.interpolateRdBu(1 - t)], + ["buylrd", (t) => d3.interpolateRdYlBu(1 - t)], + + // sequential (single-hue) + ["blues", d3.interpolateBlues], + ["greens", d3.interpolateGreens], + ["greys", d3.interpolateGreys], + ["purples", d3.interpolatePurples], + ["reds", d3.interpolateReds], + ["oranges", d3.interpolateOranges], + + // sequential (multi-hue) + ["turbo", d3.interpolateTurbo], + ["viridis", d3.interpolateViridis], + ["magma", d3.interpolateMagma], + ["inferno", d3.interpolateInferno], + ["plasma", d3.interpolatePlasma], + ["cividis", d3.interpolateCividis], + ["cubehelix", d3.interpolateCubehelixDefault], + ["warm", d3.interpolateWarm], + ["cool", d3.interpolateCool], + ["bugn", d3.interpolateBuGn], + ["bupu", d3.interpolateBuPu], + ["gnbu", d3.interpolateGnBu], + ["orrd", d3.interpolateOrRd], + ["pubugn", d3.interpolatePuBuGn], + ["pubu", d3.interpolatePuBu], + ["purd", d3.interpolatePuRd], + ["rdpu", d3.interpolateRdPu], + ["ylgnbu", d3.interpolateYlGnBu], + ["ylgn", d3.interpolateYlGn], + ["ylorbr", d3.interpolateYlOrBr], + ["ylorrd", d3.interpolateYlOrRd], + + // cyclical + ["rainbow", d3.interpolateRainbow], + ["sinebow", d3.interpolateSinebow] + ]); + + function quantitativeScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`); + return quantitativeSchemes.get(s); + } + + const divergingSchemes = new Set([ + "brbg", + "prgn", + "piyg", + "puor", + "rdbu", + "rdgy", + "rdylbu", + "rdylgn", + "spectral", + "burd", + "buylrd" + ]); + + function isDivergingScheme(scheme) { + return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase()); + } + + const flip = (i) => (t) => i(1 - t); + const unit = [0, 1]; + + const interpolators = new Map([ + // numbers + ["number", d3.interpolateNumber], + + // color spaces + ["rgb", d3.interpolateRgb], + ["hsl", d3.interpolateHsl], + ["hcl", d3.interpolateHcl], + ["lab", d3.interpolateLab] + ]); + + function maybeInterpolator(interpolate) { + const i = `${interpolate}`.toLowerCase(); + if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`); + return interpolators.get(i); + } + + function createScaleQ( + key, + scale, + channels, + { + type, + nice, + clamp, + zero, + domain = inferAutoDomain(key, channels), + unknown, + round, + scheme, + interval, + range = registry.get(key) === radius + ? inferRadialRange(channels, domain) + : registry.get(key) === length + ? inferLengthRange(channels, domain) + : registry.get(key) === opacity + ? unit + : undefined, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? d3.interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : type === "cyclical" ? "rainbow" : "turbo") + : round + ? d3.interpolateRound + : d3.interpolateNumber, + reverse + } + ) { + interval = maybeRangeInterval(interval, type); + if (type === "cyclical" || type === "sequential") type = "linear"; // shorthand for color schemes + reverse = !!reverse; + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + if (interpolate.length === 1) { + if (reverse) { + interpolate = flip(interpolate); + reverse = false; + } + if (range === undefined) { + range = Float64Array.from(domain, (_, i) => i / (domain.length - 1)); + if (range.length === 2) range = unit; // optimize common case of [0, 1] + } + scale.interpolate((range === unit ? constant$1 : interpolatePiecewise)(interpolate)); + } else { + scale.interpolate(interpolate); + } + + // If a zero option is specified, we assume that the domain is numeric, and we + // want to ensure that the domain crosses zero. However, note that the domain + // may be reversed (descending) so we shouldn’t assume that the first value is + // smaller than the last; and also it’s possible that the domain has more than + // two values for a “poly” scale. And lastly be careful not to mutate input! + if (zero) { + const [min, max] = d3.extent(domain); + if (min > 0 || max < 0) { + domain = slice(domain); + if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0; + // [2, 1] or [-2, -1] + else domain[0] = 0; // [1, 2] or [-1, -2] + } + } + + if (reverse) domain = d3.reverse(domain); + scale.domain(domain).unknown(unknown); + if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain()); + if (range !== undefined) scale.range(range); + if (clamp) scale.clamp(clamp); + return {type, domain, range, scale, interpolate, interval}; + } + + function maybeNice(nice, type) { + return nice === true ? undefined : typeof nice === "number" ? nice : maybeNiceInterval(nice, type); + } + + function createScaleLinear(key, channels, options) { + return createScaleQ(key, d3.scaleLinear(), channels, options); + } + + function createScaleSqrt(key, channels, options) { + return createScalePow(key, channels, {...options, exponent: 0.5}); + } + + function createScalePow(key, channels, {exponent = 1, ...options}) { + return createScaleQ(key, d3.scalePow().exponent(exponent), channels, {...options, type: "pow"}); + } + + function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) { + return createScaleQ(key, d3.scaleLog().base(base), channels, {...options, domain}); + } + + function createScaleSymlog(key, channels, {constant = 1, ...options}) { + return createScaleQ(key, d3.scaleSymlog().constant(constant), channels, options); + } + + function createScaleQuantile( + key, + channels, + { + range, + quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead + n = quantiles, + scheme = "rdylbu", + domain = inferQuantileDomain(channels), + unknown, + interpolate, + reverse + } + ) { + if (range === undefined) { + range = + interpolate !== undefined + ? d3.quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } + if (domain.length > 0) { + domain = d3.scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles(); + } + return createScaleThreshold(key, channels, {domain, range, reverse, unknown}); + } + + function createScaleQuantize( + key, + channels, + { + range, + n = range === undefined ? 5 : (range = [...range]).length, + scheme = "rdylbu", + domain = inferAutoDomain(key, channels), + unknown, + interpolate, + reverse + } + ) { + const [min, max] = d3.extent(domain); + let thresholds; + if (range === undefined) { + thresholds = d3.ticks(min, max, n); // approximate number of nice, round thresholds + if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound + if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound + n = thresholds.length + 1; + range = + interpolate !== undefined + ? d3.quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } else { + thresholds = d3.quantize(d3.interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range + if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types + } + if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain + return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown}); + } + + function createScaleThreshold( + key, + channels, + { + domain = [0], // explicit thresholds in ascending order + unknown, + scheme = "rdylbu", + interpolate, + range = interpolate !== undefined + ? d3.quantize(interpolate, domain.length + 1) + : registry.get(key) === color + ? ordinalRange(scheme, domain.length + 1) + : undefined, + reverse + } + ) { + domain = arrayify(domain); + const sign = orderof(domain); // preserve descending domain + if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`); + if (reverse) range = d3.reverse(range); // domain ascending, so reverse range + return { + type: "threshold", + scale: d3.scaleThreshold(sign < 0 ? d3.reverse(domain) : domain, range === undefined ? [] : range).unknown(unknown), + domain, + range + }; + } + + function isOrdered(domain, sign) { + for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) { + const s = d3.descending(d, (d = domain[i])); + if (s !== 0 && s !== sign) return false; + } + return true; + } + + function createScaleIdentity() { + return {type: "identity", scale: d3.scaleIdentity()}; + } + + function inferDomain$1(channels, f = finite) { + return channels.length + ? [ + d3.min(channels, ({value}) => (value === undefined ? value : d3.min(value, f))), + d3.max(channels, ({value}) => (value === undefined ? value : d3.max(value, f))) + ] + : [0, 1]; + } + + function inferAutoDomain(key, channels) { + const type = registry.get(key); + return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain$1)(channels); + } + + function inferZeroDomain(channels) { + return [0, channels.length ? d3.max(channels, ({value}) => (value === undefined ? value : d3.max(value, finite))) : 1]; + } + + // We don’t want the upper bound of the radial domain to be zero, as this would + // be degenerate, so we ignore nonpositive values. We also don’t want the + // maximum default radius to exceed 30px. + function inferRadialRange(channels, domain) { + const hint = channels.find(({radius}) => radius !== undefined); + if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins + const h25 = d3.quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : d3.quantile(value, 0.25, positive))); + const range = domain.map((d) => 3 * Math.sqrt(d / h25)); + const k = 30 / d3.max(range); + return k < 1 ? range.map((r) => r * k) : range; + } + + // We want a length scale’s domain to go from zero to a positive value, and to + // treat negative lengths if any as inverted vectors of equivalent magnitude. We + // also don’t want the maximum default length to exceed 60px. + function inferLengthRange(channels, domain) { + const h50 = d3.median(channels, ({value}) => (value === undefined ? NaN : d3.median(value, Math.abs))); + const range = domain.map((d) => (12 * d) / h50); + const k = 60 / d3.max(range); + return k < 1 ? range.map((r) => r * k) : range; + } + + function inferLogDomain(channels) { + for (const {value} of channels) { + if (value !== undefined) { + for (let v of value) { + if (v > 0) return inferDomain$1(channels, positive); + if (v < 0) return inferDomain$1(channels, negative); + } + } + } + return [1, 10]; + } + + function inferQuantileDomain(channels) { + const domain = []; + for (const {value} of channels) { + if (value === undefined) continue; + for (const v of value) domain.push(v); + } + return domain; + } + + function interpolatePiecewise(interpolate) { + return (i, j) => (t) => interpolate(i + t * (j - i)); + } + + function createScaleD( + key, + scale, + transform, + channels, + { + type, + nice, + clamp, + domain = inferDomain$1(channels), + unknown, + pivot = 0, + scheme, + range, + symmetric = true, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? d3.interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : "rdbu") + : d3.interpolateNumber, + reverse + } + ) { + pivot = +pivot; + let [min, max] = domain; + if (d3.descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse); + min = Math.min(min, pivot); + max = Math.max(max, pivot); + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + + // If an explicit range is specified, promote it to a piecewise interpolator. + if (range !== undefined) { + interpolate = + interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : d3.piecewise(interpolate, range); + } + + // Reverse before normalization. + if (reverse) interpolate = flip(interpolate); + + // Normalize the interpolator for symmetric difference around the pivot. + if (symmetric) { + const mid = transform.apply(pivot); + const mindelta = mid - transform.apply(min); + const maxdelta = transform.apply(max) - mid; + if (mindelta < maxdelta) min = transform.invert(mid - maxdelta); + else if (mindelta > maxdelta) max = transform.invert(mid + mindelta); + } + + scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate); + if (clamp) scale.clamp(clamp); + if (nice) scale.nice(nice); + return {type, domain: [min, max], pivot, interpolate, scale}; + } + + function createScaleDiverging(key, channels, options) { + return createScaleD(key, d3.scaleDiverging(), transformIdentity, channels, options); + } + + function createScaleDivergingSqrt(key, channels, options) { + return createScaleDivergingPow(key, channels, {...options, exponent: 0.5}); + } + + function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) { + return createScaleD(key, d3.scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, { + ...options, + type: "diverging-pow" + }); + } + + function createScaleDivergingLog( + key, + channels, + {base = 10, pivot = 1, domain = inferDomain$1(channels, pivot < 0 ? negative : positive), ...options} + ) { + return createScaleD(key, d3.scaleDivergingLog().base((base = +base)), transformLog, channels, { + domain, + pivot, + ...options + }); + } + + function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) { + return createScaleD( + key, + d3.scaleDivergingSymlog().constant((constant = +constant)), + transformSymlog(constant), + channels, + options + ); + } + + const transformIdentity = { + apply(x) { + return x; + }, + invert(x) { + return x; + } + }; + + const transformLog = { + apply: Math.log, + invert: Math.exp + }; + + const transformSqrt = { + apply(x) { + return Math.sign(x) * Math.sqrt(Math.abs(x)); + }, + invert(x) { + return Math.sign(x) * (x * x); + } + }; + + function transformPow(exponent) { + return exponent === 0.5 + ? transformSqrt + : { + apply(x) { + return Math.sign(x) * Math.pow(Math.abs(x), exponent); + }, + invert(x) { + return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent); + } + }; + } + + function transformSymlog(constant) { + return { + apply(x) { + return Math.sign(x) * Math.log1p(Math.abs(x / constant)); + }, + invert(x) { + return Math.sign(x) * Math.expm1(Math.abs(x)) * constant; + } + }; + } + + function createScaleT(key, scale, channels, options) { + return createScaleQ(key, scale, channels, options); + } + + function createScaleTime(key, channels, options) { + return createScaleT(key, d3.scaleTime(), channels, options); + } + + function createScaleUtc(key, channels, options) { + return createScaleT(key, d3.scaleUtc(), channels, options); + } + + // This denotes an implicitly ordinal color scale: the scale type was not set, + // but the associated values are strings or booleans. If the associated defined + // values are entirely boolean, the range will default to greys. You can opt out + // of this by setting the type explicitly. + const ordinalImplicit = Symbol("ordinal"); + + function createScaleO(key, scale, channels, {type, interval, domain, range, reverse, hint}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + if (type === "categorical" || type === ordinalImplicit) type = "ordinal"; // shorthand for color schemes + if (reverse) domain = d3.reverse(domain); + scale.domain(domain); + if (range !== undefined) { + // If the range is specified as a function, pass it the domain. + if (typeof range === "function") range = range(domain); + scale.range(range); + } + return {type, domain, range, scale, hint, interval}; + } + + function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + let hint; + if (registry.get(key) === symbol) { + hint = inferSymbolHint(channels); + range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol); + } else if (registry.get(key) === color) { + if (range === undefined && (type === "ordinal" || type === ordinalImplicit)) { + range = maybeBooleanRange(domain, scheme); + if (range !== undefined) scheme = undefined; // Don’t re-apply scheme. + } + if (scheme === undefined && range === undefined) { + scheme = type === "ordinal" ? "turbo" : "tableau10"; + } + if (scheme !== undefined) { + if (range !== undefined) { + const interpolate = quantitativeScheme(scheme); + const t0 = range[0], + d = range[1] - range[0]; + range = ({length: n}) => d3.quantize((t) => interpolate(t0 + d * t), n); + } else { + range = ordinalScheme(scheme); + } + } + } + if (unknown === d3.scaleImplicit) { + throw new Error(`implicit unknown on ${key} scale is not supported`); + } + return createScaleO(key, d3.scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint}); + } + + function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) { + return maybeRound(d3.scalePoint().align(align).padding(padding), channels, options, key); + } + + function createScaleBand( + key, + channels, + { + align = 0.5, + padding = 0.1, + paddingInner = padding, + paddingOuter = key === "fx" || key === "fy" ? 0 : padding, + ...options + } + ) { + return maybeRound( + d3.scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter), + channels, + options, + key + ); + } + + function maybeRound(scale, channels, options, key) { + let {round} = options; + if (round !== undefined) scale.round((round = !!round)); + scale = createScaleO(key, scale, channels, options); + scale.round = round; // preserve for autoScaleRound + return scale; + } + + function inferDomain(channels, interval, key) { + const values = new d3.InternSet(); + for (const {value, domain} of channels) { + if (domain !== undefined) return domain(); // see channelDomain + if (value === undefined) continue; + for (const v of value) values.add(v); + } + if (interval !== undefined) { + const [min, max] = d3.extent(values).map(interval.floor, interval); + return interval.range(min, interval.offset(max)); + } + if (values.size > 10e3 && registry.get(key) === position) { + throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`); + } + return d3.sort(values, ascendingDefined); + } + + // If all channels provide a consistent hint, propagate it to the scale. + function inferHint(channels, key) { + let value; + for (const {hint} of channels) { + const candidate = hint?.[key]; + if (candidate === undefined) continue; // no hint here + if (value === undefined) value = candidate; + // first hint + else if (value !== candidate) return; // inconsistent hint + } + return value; + } + + function inferSymbolHint(channels) { + return { + fill: inferHint(channels, "fill"), + stroke: inferHint(channels, "stroke") + }; + } + + function inferSymbolRange(hint) { + return isNoneish(hint.fill) ? d3.symbolsStroke : d3.symbolsFill; + } + + function normalizeScale(key, scale, hint) { + return createScale(key, hint === undefined ? undefined : [{hint}], {...scale}); + } + + function createScale(key, channels = [], options = {}) { + const type = inferScaleType(key, channels, options); + + // Warn for common misuses of implicit ordinal scales. We disable this test if + // you specify a scale interval or if you set the domain or range explicitly, + // since setting the domain or range (typically with a cardinality of more than + // two) is another indication that you intended for the scale to be ordinal; we + // also disable it for facet scales since these are always band scales. + if ( + options.type === undefined && + options.domain === undefined && + options.range === undefined && + options.interval == null && + key !== "fx" && + key !== "fy" && + isOrdinalScale({type}) + ) { + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isTemporal)) + warn( + `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isTemporalString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isNumericString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${formatScaleType( + type + )}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + } + + options.type = type; // Mutates input! + + // Once the scale type is known, coerce the associated channel values and any + // explicitly-specified domain to the expected type. + switch (type) { + case "diverging": + case "diverging-sqrt": + case "diverging-pow": + case "diverging-log": + case "diverging-symlog": + case "cyclical": + case "sequential": + case "linear": + case "sqrt": + case "threshold": + case "quantile": + case "pow": + case "log": + case "symlog": + options = coerceType(channels, options, coerceNumbers); + break; + case "identity": + switch (registry.get(key)) { + case position: + options = coerceType(channels, options, coerceNumbers); + break; + case symbol: + options = coerceType(channels, options, coerceSymbols); + break; + } + break; + case "utc": + case "time": + options = coerceType(channels, options, coerceDates); + break; + } + + switch (type) { + case "diverging": + return createScaleDiverging(key, channels, options); + case "diverging-sqrt": + return createScaleDivergingSqrt(key, channels, options); + case "diverging-pow": + return createScaleDivergingPow(key, channels, options); + case "diverging-log": + return createScaleDivergingLog(key, channels, options); + case "diverging-symlog": + return createScaleDivergingSymlog(key, channels, options); + case "categorical": + case "ordinal": + case ordinalImplicit: + return createScaleOrdinal(key, channels, options); + case "cyclical": + case "sequential": + case "linear": + return createScaleLinear(key, channels, options); + case "sqrt": + return createScaleSqrt(key, channels, options); + case "threshold": + return createScaleThreshold(key, channels, options); + case "quantile": + return createScaleQuantile(key, channels, options); + case "quantize": + return createScaleQuantize(key, channels, options); + case "pow": + return createScalePow(key, channels, options); + case "log": + return createScaleLog(key, channels, options); + case "symlog": + return createScaleSymlog(key, channels, options); + case "utc": + return createScaleUtc(key, channels, options); + case "time": + return createScaleTime(key, channels, options); + case "point": + return createScalePoint(key, channels, options); + case "band": + return createScaleBand(key, channels, options); + case "identity": + return registry.get(key) === position ? createScaleIdentity() : {type: "identity"}; + case undefined: + return; + default: + throw new Error(`unknown scale type: ${type}`); + } + } + + function formatScaleType(type) { + return typeof type === "symbol" ? type.description : type; + } + + // A special type symbol when the x and y scales are replaced with a projection. + const typeProjection = {toString: () => "projection"}; + + function inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) { + // The facet scales are always band scales; this cannot be changed. + if (key === "fx" || key === "fy") return "band"; + + // If a projection is specified, the x- and y-scales are disabled; these + // channels will be projected rather than scaled. (But still check that none + // of the associated channels are incompatible with a projection.) + if ((key === "x" || key === "y") && projection != null) type = typeProjection; + + // If a channel dictates a scale type, make sure that it is consistent with + // the user-specified scale type (if any) and all other channels. For example, + // barY requires x to be a band scale and disallows any other scale type. + for (const {type: t} of channels) { + if (t === undefined) continue; + else if (type === undefined) type = t; + else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`); + } + + // If the scale, a channel, or user specified a (consistent) type, return it. + if (type === typeProjection) return; + if (type !== undefined) return type; + + // If there’s no data (and no type) associated with this scale, don’t create a scale. + if (domain === undefined && !channels.some(({value}) => value !== undefined)) return; + + // Some scales have default types. + const kind = registry.get(key); + if (kind === radius) return "sqrt"; + if (kind === opacity || kind === length) return "linear"; + if (kind === symbol) return "ordinal"; + + // If the domain or range has more than two values, assume it’s ordinal. You + // can still use a “piecewise” (or “polylinear”) scale, but you must set the + // type explicitly. + if ((domain || range || []).length > 2) return asOrdinalType(kind); + + // Otherwise, infer the scale type from the data! Prefer the domain, if + // present, over channels. (The domain and channels should be consistently + // typed, and the domain is more explicit and typically much smaller.) We only + // check the first defined value for expedience and simplicity; we expect + // that the types are consistent. + if (domain !== undefined) { + if (isOrdinal(domain)) return asOrdinalType(kind); + if (isTemporal(domain)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; + } + + // If any channel is ordinal or temporal, it takes priority. + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isOrdinal)) return asOrdinalType(kind); + if (values.some(isTemporal)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; + } + + // Positional scales default to a point scale instead of an ordinal scale. + function asOrdinalType(kind) { + switch (kind) { + case position: + return "point"; + case color: + return ordinalImplicit; + default: + return "ordinal"; + } + } + + function isOrdinalScale({type}) { + return type === "ordinal" || type === "point" || type === "band" || type === ordinalImplicit; + } + + // Mutates channel.value! + function coerceType(channels, {domain, ...options}, coerceValues) { + for (const c of channels) { + if (c.value !== undefined) { + c.value = coerceValues(c.value); + } + } + return { + domain: domain === undefined ? domain : coerceValues(domain), + ...options + }; + } + + function coerceSymbols(values) { + return map(values, maybeSymbol); + } + + function scale(options = {}) { + let scale; + for (const key in options) { + if (!registry.has(key)) continue; // ignore unknown properties + if (!isScaleOptions(options[key])) continue; // e.g., ignore {color: "red"} + if (scale !== undefined) throw new Error("ambiguous scale definition; multiple scales found"); + scale = exposeScale(normalizeScale(key, options[key])); + } + if (scale === undefined) throw new Error("invalid scale definition; no scale found"); + return scale; + } + + // Note: axis- and legend-related properties (such as label, ticks and + // tickFormat) are not included here as they do not affect the scale’s behavior. + function exposeScale({scale, type, domain, range, interpolate, interval, transform, percent, pivot}) { + if (type === "identity") return {type: "identity", apply: (d) => d, invert: (d) => d}; + const unknown = scale.unknown ? scale.unknown() : undefined; + return { + type, + domain: slice(domain), // defensive copy + ...(range !== undefined && {range: slice(range)}), // defensive copy + ...(transform !== undefined && {transform}), + ...(percent && {percent}), // only exposed if truthy + ...(unknown !== undefined && {unknown}), + ...(interval !== undefined && {interval}), + + // quantitative + ...(interpolate !== undefined && {interpolate}), + ...(scale.clamp && {clamp: scale.clamp()}), + + // diverging (always asymmetric; we never want to apply the symmetric transform twice) + ...(pivot !== undefined && {pivot, symmetric: false}), + + // log, diverging-log + ...(scale.base && {base: scale.base()}), + + // pow, diverging-pow + ...(scale.exponent && {exponent: scale.exponent()}), + + // symlog, diverging-symlog + ...(scale.constant && {constant: scale.constant()}), + + // band, point + ...(scale.align && {align: scale.align(), round: scale.round()}), + ...(scale.padding && + (scale.paddingInner + ? {paddingInner: scale.paddingInner(), paddingOuter: scale.paddingOuter()} + : {padding: scale.padding()})), + ...(scale.bandwidth && {bandwidth: scale.bandwidth(), step: scale.step()}), + + // utilities + apply: (t) => scale(t), + ...(scale.invert && {invert: (t) => scale.invert(t)}) + }; + } + + function normalizedScale(scaleOptions) { + try { + var scaleType = Object.keys(scaleOptions)[0]; + return scale(_defineProperty({}, scaleType, Object.assign(Object.assign({}, scaleOptions[scaleType]), { + clamp: true + }))); + } catch (error) { + return null; + } + } + function scaleStyle(_scale, scaleOptions) { + var styles = {}; + if (scaleOptions.hasOwnProperty('opacity')) { + styles.fill = function () { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + scaleOptions.opacity.baseColor || SCALE_BASE_OPACITY_COLOR + ); + }; + styles['fill-opacity'] = function (d) { + return _scale === null || _scale === void 0 ? void 0 : _scale.apply(d); + }; + } else { + styles.fill = function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + typeof d === 'string' && (d === null || d === void 0 ? void 0 : d.startsWith('#')) ? d : _scale === null || _scale === void 0 ? void 0 : _scale.apply(d) + ); + }; + } + return styles; + } + function applyScaleStyle(elem, _scale, scaleOptions, keyname) { + Object.entries(scaleStyle(_scale, scaleOptions)).forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + prop = _ref2[0], + val = _ref2[1]; + return ( + // eslint-disable-next-line implicit-arrow-linebreak + elem.style(prop, function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + val(keyname ? d[keyname] : d) + ); + }) + ); + }); + } + + var Populator = /*#__PURE__*/function () { + function Populator(calendar) { + _classCallCheck(this, Populator); + this.calendar = calendar; + } + _createClass(Populator, [{ + key: "populate", + value: function populate() { + var calendar = this.calendar; + var _calendar$options$opt = calendar.options.options, + scale = _calendar$options$opt.scale, + subDomain = _calendar$options$opt.subDomain; + var colorScale = normalizedScale(scale); + calendar.calendarPainter.root.selectAll('.ch-domain').selectAll('svg').selectAll('g').data(function (d) { + return calendar.domainCollection.get(d) || []; + }).call(function (element) { + applyScaleStyle(element.select('rect'), colorScale, scale, 'v'); + }).call(function (element) { + element.select('text').attr('style', function (d) { + var defaultColor = d3Color.hcl(colorScale === null || colorScale === void 0 ? void 0 : colorScale.apply(d.v)).l > 60 ? '#000' : '#fff'; + var color = subDomain.color || (d.v ? defaultColor : null); + if (isFunction(color)) { + color = color(d.t, d.v, colorScale === null || colorScale === void 0 ? void 0 : colorScale.apply(d.v)); + } + if (!color) { + return null; + } + return "fill: ".concat(color, ";"); + }).text(function (d, i, nodes) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + calendar.dateHelper.format(d.t, subDomain.label, d.v, nodes[i]) + ); + }); + }).call(function () { + calendar.eventEmitter.emit('fill'); + }); + } + }]); + return Populator; + }(); + + /** + * Removes all key-value entries from the list cache. + * + * @private + * @name clear + * @memberOf ListCache + */ + function listCacheClear() { + this.__data__ = []; + this.size = 0; + } + + /** + * Performs a + * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * comparison between two values to determine if they are equivalent. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.eq(object, object); + * // => true + * + * _.eq(object, other); + * // => false + * + * _.eq('a', 'a'); + * // => true + * + * _.eq('a', Object('a')); + * // => false + * + * _.eq(NaN, NaN); + * // => true + */ + function eq(value, other) { + return value === other || (value !== value && other !== other); + } + + /** + * Gets the index at which the `key` is found in `array` of key-value pairs. + * + * @private + * @param {Array} array The array to inspect. + * @param {*} key The key to search for. + * @returns {number} Returns the index of the matched value, else `-1`. + */ + function assocIndexOf(array, key) { + var length = array.length; + while (length--) { + if (eq(array[length][0], key)) { + return length; + } + } + return -1; + } + + /** Used for built-in method references. */ + var arrayProto = Array.prototype; + + /** Built-in value references. */ + var splice = arrayProto.splice; + + /** + * Removes `key` and its value from the list cache. + * + * @private + * @name delete + * @memberOf ListCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function listCacheDelete(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + return false; + } + var lastIndex = data.length - 1; + if (index == lastIndex) { + data.pop(); + } else { + splice.call(data, index, 1); + } + --this.size; + return true; + } + + /** + * Gets the list cache value for `key`. + * + * @private + * @name get + * @memberOf ListCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function listCacheGet(key) { + var data = this.__data__, + index = assocIndexOf(data, key); + + return index < 0 ? undefined : data[index][1]; + } + + /** + * Checks if a list cache value for `key` exists. + * + * @private + * @name has + * @memberOf ListCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function listCacheHas(key) { + return assocIndexOf(this.__data__, key) > -1; + } + + /** + * Sets the list cache `key` to `value`. + * + * @private + * @name set + * @memberOf ListCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the list cache instance. + */ + function listCacheSet(key, value) { + var data = this.__data__, + index = assocIndexOf(data, key); + + if (index < 0) { + ++this.size; + data.push([key, value]); + } else { + data[index][1] = value; + } + return this; + } + + /** + * Creates an list cache object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function ListCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + // Add methods to `ListCache`. + ListCache.prototype.clear = listCacheClear; + ListCache.prototype['delete'] = listCacheDelete; + ListCache.prototype.get = listCacheGet; + ListCache.prototype.has = listCacheHas; + ListCache.prototype.set = listCacheSet; + + /** + * Removes all key-value entries from the stack. + * + * @private + * @name clear + * @memberOf Stack + */ + function stackClear() { + this.__data__ = new ListCache; + this.size = 0; + } + + /** + * Removes `key` and its value from the stack. + * + * @private + * @name delete + * @memberOf Stack + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function stackDelete(key) { + var data = this.__data__, + result = data['delete'](key); + + this.size = data.size; + return result; + } + + /** + * Gets the stack value for `key`. + * + * @private + * @name get + * @memberOf Stack + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function stackGet(key) { + return this.__data__.get(key); + } + + /** + * Checks if a stack value for `key` exists. + * + * @private + * @name has + * @memberOf Stack + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function stackHas(key) { + return this.__data__.has(key); + } + + /** Used to detect overreaching core-js shims. */ + var coreJsData = root$1['__core-js_shared__']; + + var coreJsData$1 = coreJsData; + + /** Used to detect methods masquerading as native. */ + var maskSrcKey = (function() { + var uid = /[^.]+$/.exec(coreJsData$1 && coreJsData$1.keys && coreJsData$1.keys.IE_PROTO || ''); + return uid ? ('Symbol(src)_1.' + uid) : ''; + }()); + + /** + * Checks if `func` has its source masked. + * + * @private + * @param {Function} func The function to check. + * @returns {boolean} Returns `true` if `func` is masked, else `false`. + */ + function isMasked(func) { + return !!maskSrcKey && (maskSrcKey in func); + } + + /** Used for built-in method references. */ + var funcProto$2 = Function.prototype; + + /** Used to resolve the decompiled source of functions. */ + var funcToString$2 = funcProto$2.toString; + + /** + * Converts `func` to its source code. + * + * @private + * @param {Function} func The function to convert. + * @returns {string} Returns the source code. + */ + function toSource(func) { + if (func != null) { + try { + return funcToString$2.call(func); + } catch (e) {} + try { + return (func + ''); + } catch (e) {} + } + return ''; + } + + /** + * Used to match `RegExp` + * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns). + */ + var reRegExpChar = /[\\^$.*+?()[\]{}|]/g; + + /** Used to detect host constructors (Safari). */ + var reIsHostCtor = /^\[object .+?Constructor\]$/; + + /** Used for built-in method references. */ + var funcProto$1 = Function.prototype, + objectProto$d = Object.prototype; + + /** Used to resolve the decompiled source of functions. */ + var funcToString$1 = funcProto$1.toString; + + /** Used to check objects for own properties. */ + var hasOwnProperty$b = objectProto$d.hasOwnProperty; + + /** Used to detect if a method is native. */ + var reIsNative = RegExp('^' + + funcToString$1.call(hasOwnProperty$b).replace(reRegExpChar, '\\$&') + .replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g, '$1.*?') + '$' + ); + + /** + * The base implementation of `_.isNative` without bad shim checks. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a native function, + * else `false`. + */ + function baseIsNative(value) { + if (!isObject$2(value) || isMasked(value)) { + return false; + } + var pattern = isFunction(value) ? reIsNative : reIsHostCtor; + return pattern.test(toSource(value)); + } + + /** + * Gets the value at `key` of `object`. + * + * @private + * @param {Object} [object] The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + function getValue(object, key) { + return object == null ? undefined : object[key]; + } + + /** + * Gets the native function at `key` of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the method to get. + * @returns {*} Returns the function if it's native, else `undefined`. + */ + function getNative(object, key) { + var value = getValue(object, key); + return baseIsNative(value) ? value : undefined; + } + + /* Built-in method references that are verified to be native. */ + var Map$1 = getNative(root$1, 'Map'); + + var Map$2 = Map$1; + + /* Built-in method references that are verified to be native. */ + var nativeCreate = getNative(Object, 'create'); + + var nativeCreate$1 = nativeCreate; + + /** + * Removes all key-value entries from the hash. + * + * @private + * @name clear + * @memberOf Hash + */ + function hashClear() { + this.__data__ = nativeCreate$1 ? nativeCreate$1(null) : {}; + this.size = 0; + } + + /** + * Removes `key` and its value from the hash. + * + * @private + * @name delete + * @memberOf Hash + * @param {Object} hash The hash to modify. + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function hashDelete(key) { + var result = this.has(key) && delete this.__data__[key]; + this.size -= result ? 1 : 0; + return result; + } + + /** Used to stand-in for `undefined` hash values. */ + var HASH_UNDEFINED$2 = '__lodash_hash_undefined__'; + + /** Used for built-in method references. */ + var objectProto$c = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$a = objectProto$c.hasOwnProperty; + + /** + * Gets the hash value for `key`. + * + * @private + * @name get + * @memberOf Hash + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function hashGet(key) { + var data = this.__data__; + if (nativeCreate$1) { + var result = data[key]; + return result === HASH_UNDEFINED$2 ? undefined : result; + } + return hasOwnProperty$a.call(data, key) ? data[key] : undefined; + } + + /** Used for built-in method references. */ + var objectProto$b = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$9 = objectProto$b.hasOwnProperty; + + /** + * Checks if a hash value for `key` exists. + * + * @private + * @name has + * @memberOf Hash + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function hashHas(key) { + var data = this.__data__; + return nativeCreate$1 ? (data[key] !== undefined) : hasOwnProperty$9.call(data, key); + } + + /** Used to stand-in for `undefined` hash values. */ + var HASH_UNDEFINED$1 = '__lodash_hash_undefined__'; + + /** + * Sets the hash `key` to `value`. + * + * @private + * @name set + * @memberOf Hash + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the hash instance. + */ + function hashSet(key, value) { + var data = this.__data__; + this.size += this.has(key) ? 0 : 1; + data[key] = (nativeCreate$1 && value === undefined) ? HASH_UNDEFINED$1 : value; + return this; + } + + /** + * Creates a hash object. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function Hash(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + // Add methods to `Hash`. + Hash.prototype.clear = hashClear; + Hash.prototype['delete'] = hashDelete; + Hash.prototype.get = hashGet; + Hash.prototype.has = hashHas; + Hash.prototype.set = hashSet; + + /** + * Removes all key-value entries from the map. + * + * @private + * @name clear + * @memberOf MapCache + */ + function mapCacheClear() { + this.size = 0; + this.__data__ = { + 'hash': new Hash, + 'map': new (Map$2 || ListCache), + 'string': new Hash + }; + } + + /** + * Checks if `value` is suitable for use as unique object key. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is suitable, else `false`. + */ + function isKeyable(value) { + var type = typeof value; + return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean') + ? (value !== '__proto__') + : (value === null); + } + + /** + * Gets the data for `map`. + * + * @private + * @param {Object} map The map to query. + * @param {string} key The reference key. + * @returns {*} Returns the map data. + */ + function getMapData(map, key) { + var data = map.__data__; + return isKeyable(key) + ? data[typeof key == 'string' ? 'string' : 'hash'] + : data.map; + } + + /** + * Removes `key` and its value from the map. + * + * @private + * @name delete + * @memberOf MapCache + * @param {string} key The key of the value to remove. + * @returns {boolean} Returns `true` if the entry was removed, else `false`. + */ + function mapCacheDelete(key) { + var result = getMapData(this, key)['delete'](key); + this.size -= result ? 1 : 0; + return result; + } + + /** + * Gets the map value for `key`. + * + * @private + * @name get + * @memberOf MapCache + * @param {string} key The key of the value to get. + * @returns {*} Returns the entry value. + */ + function mapCacheGet(key) { + return getMapData(this, key).get(key); + } + + /** + * Checks if a map value for `key` exists. + * + * @private + * @name has + * @memberOf MapCache + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function mapCacheHas(key) { + return getMapData(this, key).has(key); + } + + /** + * Sets the map `key` to `value`. + * + * @private + * @name set + * @memberOf MapCache + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the map cache instance. + */ + function mapCacheSet(key, value) { + var data = getMapData(this, key), + size = data.size; + + data.set(key, value); + this.size += data.size == size ? 0 : 1; + return this; + } + + /** + * Creates a map cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function MapCache(entries) { + var index = -1, + length = entries == null ? 0 : entries.length; + + this.clear(); + while (++index < length) { + var entry = entries[index]; + this.set(entry[0], entry[1]); + } + } + + // Add methods to `MapCache`. + MapCache.prototype.clear = mapCacheClear; + MapCache.prototype['delete'] = mapCacheDelete; + MapCache.prototype.get = mapCacheGet; + MapCache.prototype.has = mapCacheHas; + MapCache.prototype.set = mapCacheSet; + + /** Used as the size to enable large array optimizations. */ + var LARGE_ARRAY_SIZE = 200; + + /** + * Sets the stack `key` to `value`. + * + * @private + * @name set + * @memberOf Stack + * @param {string} key The key of the value to set. + * @param {*} value The value to set. + * @returns {Object} Returns the stack cache instance. + */ + function stackSet(key, value) { + var data = this.__data__; + if (data instanceof ListCache) { + var pairs = data.__data__; + if (!Map$2 || (pairs.length < LARGE_ARRAY_SIZE - 1)) { + pairs.push([key, value]); + this.size = ++data.size; + return this; + } + data = this.__data__ = new MapCache(pairs); + } + data.set(key, value); + this.size = data.size; + return this; + } + + /** + * Creates a stack cache object to store key-value pairs. + * + * @private + * @constructor + * @param {Array} [entries] The key-value pairs to cache. + */ + function Stack(entries) { + var data = this.__data__ = new ListCache(entries); + this.size = data.size; + } + + // Add methods to `Stack`. + Stack.prototype.clear = stackClear; + Stack.prototype['delete'] = stackDelete; + Stack.prototype.get = stackGet; + Stack.prototype.has = stackHas; + Stack.prototype.set = stackSet; + + var defineProperty = (function() { + try { + var func = getNative(Object, 'defineProperty'); + func({}, '', {}); + return func; + } catch (e) {} + }()); + + var defineProperty$1 = defineProperty; + + /** + * The base implementation of `assignValue` and `assignMergeValue` without + * value checks. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function baseAssignValue(object, key, value) { + if (key == '__proto__' && defineProperty$1) { + defineProperty$1(object, key, { + 'configurable': true, + 'enumerable': true, + 'value': value, + 'writable': true + }); + } else { + object[key] = value; + } + } + + /** + * This function is like `assignValue` except that it doesn't assign + * `undefined` values. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function assignMergeValue(object, key, value) { + if ((value !== undefined && !eq(object[key], value)) || + (value === undefined && !(key in object))) { + baseAssignValue(object, key, value); + } + } + + /** + * Creates a base function for methods like `_.forIn` and `_.forOwn`. + * + * @private + * @param {boolean} [fromRight] Specify iterating from right to left. + * @returns {Function} Returns the new base function. + */ + function createBaseFor(fromRight) { + return function(object, iteratee, keysFunc) { + var index = -1, + iterable = Object(object), + props = keysFunc(object), + length = props.length; + + while (length--) { + var key = props[fromRight ? length : ++index]; + if (iteratee(iterable[key], key, iterable) === false) { + break; + } + } + return object; + }; + } + + /** + * The base implementation of `baseForOwn` which iterates over `object` + * properties returned by `keysFunc` and invokes `iteratee` for each property. + * Iteratee functions may exit iteration early by explicitly returning `false`. + * + * @private + * @param {Object} object The object to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @param {Function} keysFunc The function to get the keys of `object`. + * @returns {Object} Returns `object`. + */ + var baseFor = createBaseFor(); + + var baseFor$1 = baseFor; + + /** Detect free variable `exports`. */ + var freeExports$2 = typeof exports == 'object' && exports && !exports.nodeType && exports; + + /** Detect free variable `module`. */ + var freeModule$2 = freeExports$2 && typeof module == 'object' && module && !module.nodeType && module; + + /** Detect the popular CommonJS extension `module.exports`. */ + var moduleExports$2 = freeModule$2 && freeModule$2.exports === freeExports$2; + + /** Built-in value references. */ + var Buffer$1 = moduleExports$2 ? root$1.Buffer : undefined, + allocUnsafe = Buffer$1 ? Buffer$1.allocUnsafe : undefined; + + /** + * Creates a clone of `buffer`. + * + * @private + * @param {Buffer} buffer The buffer to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Buffer} Returns the cloned buffer. + */ + function cloneBuffer(buffer, isDeep) { + if (isDeep) { + return buffer.slice(); + } + var length = buffer.length, + result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length); + + buffer.copy(result); + return result; + } + + /** Built-in value references. */ + var Uint8Array$1 = root$1.Uint8Array; + + var Uint8Array$2 = Uint8Array$1; + + /** + * Creates a clone of `arrayBuffer`. + * + * @private + * @param {ArrayBuffer} arrayBuffer The array buffer to clone. + * @returns {ArrayBuffer} Returns the cloned array buffer. + */ + function cloneArrayBuffer(arrayBuffer) { + var result = new arrayBuffer.constructor(arrayBuffer.byteLength); + new Uint8Array$2(result).set(new Uint8Array$2(arrayBuffer)); + return result; + } + + /** + * Creates a clone of `typedArray`. + * + * @private + * @param {Object} typedArray The typed array to clone. + * @param {boolean} [isDeep] Specify a deep clone. + * @returns {Object} Returns the cloned typed array. + */ + function cloneTypedArray(typedArray, isDeep) { + var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer; + return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length); + } + + /** + * Copies the values of `source` to `array`. + * + * @private + * @param {Array} source The array to copy values from. + * @param {Array} [array=[]] The array to copy values to. + * @returns {Array} Returns `array`. + */ + function copyArray(source, array) { + var index = -1, + length = source.length; + + array || (array = Array(length)); + while (++index < length) { + array[index] = source[index]; + } + return array; + } + + /** Built-in value references. */ + var objectCreate = Object.create; + + /** + * The base implementation of `_.create` without support for assigning + * properties to the created object. + * + * @private + * @param {Object} proto The object to inherit from. + * @returns {Object} Returns the new object. + */ + var baseCreate = (function() { + function object() {} + return function(proto) { + if (!isObject$2(proto)) { + return {}; + } + if (objectCreate) { + return objectCreate(proto); + } + object.prototype = proto; + var result = new object; + object.prototype = undefined; + return result; + }; + }()); + + var baseCreate$1 = baseCreate; + + /** + * Creates a unary function that invokes `func` with its argument transformed. + * + * @private + * @param {Function} func The function to wrap. + * @param {Function} transform The argument transform. + * @returns {Function} Returns the new function. + */ + function overArg(func, transform) { + return function(arg) { + return func(transform(arg)); + }; + } + + /** Built-in value references. */ + var getPrototype = overArg(Object.getPrototypeOf, Object); + + var getPrototype$1 = getPrototype; + + /** Used for built-in method references. */ + var objectProto$a = Object.prototype; + + /** + * Checks if `value` is likely a prototype object. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a prototype, else `false`. + */ + function isPrototype(value) { + var Ctor = value && value.constructor, + proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto$a; + + return value === proto; + } + + /** + * Initializes an object clone. + * + * @private + * @param {Object} object The object to clone. + * @returns {Object} Returns the initialized clone. + */ + function initCloneObject(object) { + return (typeof object.constructor == 'function' && !isPrototype(object)) + ? baseCreate$1(getPrototype$1(object)) + : {}; + } + + /** + * Checks if `value` is object-like. A value is object-like if it's not `null` + * and has a `typeof` result of "object". + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is object-like, else `false`. + * @example + * + * _.isObjectLike({}); + * // => true + * + * _.isObjectLike([1, 2, 3]); + * // => true + * + * _.isObjectLike(_.noop); + * // => false + * + * _.isObjectLike(null); + * // => false + */ + function isObjectLike(value) { + return value != null && typeof value == 'object'; + } + + /** `Object#toString` result references. */ + var argsTag$2 = '[object Arguments]'; + + /** + * The base implementation of `_.isArguments`. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + */ + function baseIsArguments(value) { + return isObjectLike(value) && baseGetTag(value) == argsTag$2; + } + + /** Used for built-in method references. */ + var objectProto$9 = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$8 = objectProto$9.hasOwnProperty; + + /** Built-in value references. */ + var propertyIsEnumerable$1 = objectProto$9.propertyIsEnumerable; + + /** + * Checks if `value` is likely an `arguments` object. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an `arguments` object, + * else `false`. + * @example + * + * _.isArguments(function() { return arguments; }()); + * // => true + * + * _.isArguments([1, 2, 3]); + * // => false + */ + var isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) { + return isObjectLike(value) && hasOwnProperty$8.call(value, 'callee') && + !propertyIsEnumerable$1.call(value, 'callee'); + }; + + var isArguments$1 = isArguments; + + /** Used as references for various `Number` constants. */ + var MAX_SAFE_INTEGER$1 = 9007199254740991; + + /** + * Checks if `value` is a valid array-like length. + * + * **Note:** This method is loosely based on + * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength). + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a valid length, else `false`. + * @example + * + * _.isLength(3); + * // => true + * + * _.isLength(Number.MIN_VALUE); + * // => false + * + * _.isLength(Infinity); + * // => false + * + * _.isLength('3'); + * // => false + */ + function isLength(value) { + return typeof value == 'number' && + value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER$1; + } + + /** + * Checks if `value` is array-like. A value is considered array-like if it's + * not a function and has a `value.length` that's an integer greater than or + * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is array-like, else `false`. + * @example + * + * _.isArrayLike([1, 2, 3]); + * // => true + * + * _.isArrayLike(document.body.children); + * // => true + * + * _.isArrayLike('abc'); + * // => true + * + * _.isArrayLike(_.noop); + * // => false + */ + function isArrayLike(value) { + return value != null && isLength(value.length) && !isFunction(value); + } + + /** + * This method is like `_.isArrayLike` except that it also checks if `value` + * is an object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is an array-like object, + * else `false`. + * @example + * + * _.isArrayLikeObject([1, 2, 3]); + * // => true + * + * _.isArrayLikeObject(document.body.children); + * // => true + * + * _.isArrayLikeObject('abc'); + * // => false + * + * _.isArrayLikeObject(_.noop); + * // => false + */ + function isArrayLikeObject(value) { + return isObjectLike(value) && isArrayLike(value); + } + + /** + * This method returns `false`. + * + * @static + * @memberOf _ + * @since 4.13.0 + * @category Util + * @returns {boolean} Returns `false`. + * @example + * + * _.times(2, _.stubFalse); + * // => [false, false] + */ + function stubFalse() { + return false; + } + + /** Detect free variable `exports`. */ + var freeExports$1 = typeof exports == 'object' && exports && !exports.nodeType && exports; + + /** Detect free variable `module`. */ + var freeModule$1 = freeExports$1 && typeof module == 'object' && module && !module.nodeType && module; + + /** Detect the popular CommonJS extension `module.exports`. */ + var moduleExports$1 = freeModule$1 && freeModule$1.exports === freeExports$1; + + /** Built-in value references. */ + var Buffer = moduleExports$1 ? root$1.Buffer : undefined; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined; + + /** + * Checks if `value` is a buffer. + * + * @static + * @memberOf _ + * @since 4.3.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a buffer, else `false`. + * @example + * + * _.isBuffer(new Buffer(2)); + * // => true + * + * _.isBuffer(new Uint8Array(2)); + * // => false + */ + var isBuffer = nativeIsBuffer || stubFalse; + + var isBuffer$1 = isBuffer; + + /** `Object#toString` result references. */ + var objectTag$3 = '[object Object]'; + + /** Used for built-in method references. */ + var funcProto = Function.prototype, + objectProto$8 = Object.prototype; + + /** Used to resolve the decompiled source of functions. */ + var funcToString = funcProto.toString; + + /** Used to check objects for own properties. */ + var hasOwnProperty$7 = objectProto$8.hasOwnProperty; + + /** Used to infer the `Object` constructor. */ + var objectCtorString = funcToString.call(Object); + + /** + * Checks if `value` is a plain object, that is, an object created by the + * `Object` constructor or one with a `[[Prototype]]` of `null`. + * + * @static + * @memberOf _ + * @since 0.8.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a plain object, else `false`. + * @example + * + * function Foo() { + * this.a = 1; + * } + * + * _.isPlainObject(new Foo); + * // => false + * + * _.isPlainObject([1, 2, 3]); + * // => false + * + * _.isPlainObject({ 'x': 0, 'y': 0 }); + * // => true + * + * _.isPlainObject(Object.create(null)); + * // => true + */ + function isPlainObject(value) { + if (!isObjectLike(value) || baseGetTag(value) != objectTag$3) { + return false; + } + var proto = getPrototype$1(value); + if (proto === null) { + return true; + } + var Ctor = hasOwnProperty$7.call(proto, 'constructor') && proto.constructor; + return typeof Ctor == 'function' && Ctor instanceof Ctor && + funcToString.call(Ctor) == objectCtorString; + } + + /** `Object#toString` result references. */ + var argsTag$1 = '[object Arguments]', + arrayTag$1 = '[object Array]', + boolTag$1 = '[object Boolean]', + dateTag$1 = '[object Date]', + errorTag$1 = '[object Error]', + funcTag = '[object Function]', + mapTag$2 = '[object Map]', + numberTag$1 = '[object Number]', + objectTag$2 = '[object Object]', + regexpTag$1 = '[object RegExp]', + setTag$2 = '[object Set]', + stringTag$2 = '[object String]', + weakMapTag$1 = '[object WeakMap]'; + + var arrayBufferTag$1 = '[object ArrayBuffer]', + dataViewTag$2 = '[object DataView]', + float32Tag = '[object Float32Array]', + float64Tag = '[object Float64Array]', + int8Tag = '[object Int8Array]', + int16Tag = '[object Int16Array]', + int32Tag = '[object Int32Array]', + uint8Tag = '[object Uint8Array]', + uint8ClampedTag = '[object Uint8ClampedArray]', + uint16Tag = '[object Uint16Array]', + uint32Tag = '[object Uint32Array]'; + + /** Used to identify `toStringTag` values of typed arrays. */ + var typedArrayTags = {}; + typedArrayTags[float32Tag] = typedArrayTags[float64Tag] = + typedArrayTags[int8Tag] = typedArrayTags[int16Tag] = + typedArrayTags[int32Tag] = typedArrayTags[uint8Tag] = + typedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] = + typedArrayTags[uint32Tag] = true; + typedArrayTags[argsTag$1] = typedArrayTags[arrayTag$1] = + typedArrayTags[arrayBufferTag$1] = typedArrayTags[boolTag$1] = + typedArrayTags[dataViewTag$2] = typedArrayTags[dateTag$1] = + typedArrayTags[errorTag$1] = typedArrayTags[funcTag] = + typedArrayTags[mapTag$2] = typedArrayTags[numberTag$1] = + typedArrayTags[objectTag$2] = typedArrayTags[regexpTag$1] = + typedArrayTags[setTag$2] = typedArrayTags[stringTag$2] = + typedArrayTags[weakMapTag$1] = false; + + /** + * The base implementation of `_.isTypedArray` without Node.js optimizations. + * + * @private + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + */ + function baseIsTypedArray(value) { + return isObjectLike(value) && + isLength(value.length) && !!typedArrayTags[baseGetTag(value)]; + } + + /** + * The base implementation of `_.unary` without support for storing metadata. + * + * @private + * @param {Function} func The function to cap arguments for. + * @returns {Function} Returns the new capped function. + */ + function baseUnary(func) { + return function(value) { + return func(value); + }; + } + + /** Detect free variable `exports`. */ + var freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports; + + /** Detect free variable `module`. */ + var freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module; + + /** Detect the popular CommonJS extension `module.exports`. */ + var moduleExports = freeModule && freeModule.exports === freeExports; + + /** Detect free variable `process` from Node.js. */ + var freeProcess = moduleExports && freeGlobal$1.process; + + /** Used to access faster Node.js helpers. */ + var nodeUtil = (function() { + try { + // Use `util.types` for Node.js 10+. + var types = freeModule && freeModule.require && freeModule.require('util').types; + + if (types) { + return types; + } + + // Legacy `process.binding('util')` for Node.js < 10. + return freeProcess && freeProcess.binding && freeProcess.binding('util'); + } catch (e) {} + }()); + + var nodeUtil$1 = nodeUtil; + + /* Node.js helper references. */ + var nodeIsTypedArray = nodeUtil$1 && nodeUtil$1.isTypedArray; + + /** + * Checks if `value` is classified as a typed array. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a typed array, else `false`. + * @example + * + * _.isTypedArray(new Uint8Array); + * // => true + * + * _.isTypedArray([]); + * // => false + */ + var isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray; + + var isTypedArray$1 = isTypedArray; + + /** + * Gets the value at `key`, unless `key` is "__proto__" or "constructor". + * + * @private + * @param {Object} object The object to query. + * @param {string} key The key of the property to get. + * @returns {*} Returns the property value. + */ + function safeGet(object, key) { + if (key === 'constructor' && typeof object[key] === 'function') { + return; + } + + if (key == '__proto__') { + return; + } + + return object[key]; + } + + /** Used for built-in method references. */ + var objectProto$7 = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$6 = objectProto$7.hasOwnProperty; + + /** + * Assigns `value` to `key` of `object` if the existing value is not equivalent + * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero) + * for equality comparisons. + * + * @private + * @param {Object} object The object to modify. + * @param {string} key The key of the property to assign. + * @param {*} value The value to assign. + */ + function assignValue(object, key, value) { + var objValue = object[key]; + if (!(hasOwnProperty$6.call(object, key) && eq(objValue, value)) || + (value === undefined && !(key in object))) { + baseAssignValue(object, key, value); + } + } + + /** + * Copies properties of `source` to `object`. + * + * @private + * @param {Object} source The object to copy properties from. + * @param {Array} props The property identifiers to copy. + * @param {Object} [object={}] The object to copy properties to. + * @param {Function} [customizer] The function to customize copied values. + * @returns {Object} Returns `object`. + */ + function copyObject(source, props, object, customizer) { + var isNew = !object; + object || (object = {}); + + var index = -1, + length = props.length; + + while (++index < length) { + var key = props[index]; + + var newValue = customizer + ? customizer(object[key], source[key], key, object, source) + : undefined; + + if (newValue === undefined) { + newValue = source[key]; + } + if (isNew) { + baseAssignValue(object, key, newValue); + } else { + assignValue(object, key, newValue); + } + } + return object; + } + + /** + * The base implementation of `_.times` without support for iteratee shorthands + * or max array length checks. + * + * @private + * @param {number} n The number of times to invoke `iteratee`. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the array of results. + */ + function baseTimes(n, iteratee) { + var index = -1, + result = Array(n); + + while (++index < n) { + result[index] = iteratee(index); + } + return result; + } + + /** Used as references for various `Number` constants. */ + var MAX_SAFE_INTEGER = 9007199254740991; + + /** Used to detect unsigned integer values. */ + var reIsUint = /^(?:0|[1-9]\d*)$/; + + /** + * Checks if `value` is a valid array-like index. + * + * @private + * @param {*} value The value to check. + * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index. + * @returns {boolean} Returns `true` if `value` is a valid index, else `false`. + */ + function isIndex(value, length) { + var type = typeof value; + length = length == null ? MAX_SAFE_INTEGER : length; + + return !!length && + (type == 'number' || + (type != 'symbol' && reIsUint.test(value))) && + (value > -1 && value % 1 == 0 && value < length); + } + + /** Used for built-in method references. */ + var objectProto$6 = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$5 = objectProto$6.hasOwnProperty; + + /** + * Creates an array of the enumerable property names of the array-like `value`. + * + * @private + * @param {*} value The value to query. + * @param {boolean} inherited Specify returning inherited property names. + * @returns {Array} Returns the array of property names. + */ + function arrayLikeKeys(value, inherited) { + var isArr = isArray$3(value), + isArg = !isArr && isArguments$1(value), + isBuff = !isArr && !isArg && isBuffer$1(value), + isType = !isArr && !isArg && !isBuff && isTypedArray$1(value), + skipIndexes = isArr || isArg || isBuff || isType, + result = skipIndexes ? baseTimes(value.length, String) : [], + length = result.length; + + for (var key in value) { + if ((inherited || hasOwnProperty$5.call(value, key)) && + !(skipIndexes && ( + // Safari 9 has enumerable `arguments.length` in strict mode. + key == 'length' || + // Node.js 0.10 has enumerable non-index properties on buffers. + (isBuff && (key == 'offset' || key == 'parent')) || + // PhantomJS 2 has enumerable non-index properties on typed arrays. + (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) || + // Skip index properties. + isIndex(key, length) + ))) { + result.push(key); + } + } + return result; + } + + /** + * This function is like + * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * except that it includes inherited enumerable properties. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function nativeKeysIn(object) { + var result = []; + if (object != null) { + for (var key in Object(object)) { + result.push(key); + } + } + return result; + } + + /** Used for built-in method references. */ + var objectProto$5 = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$4 = objectProto$5.hasOwnProperty; + + /** + * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function baseKeysIn(object) { + if (!isObject$2(object)) { + return nativeKeysIn(object); + } + var isProto = isPrototype(object), + result = []; + + for (var key in object) { + if (!(key == 'constructor' && (isProto || !hasOwnProperty$4.call(object, key)))) { + result.push(key); + } + } + return result; + } + + /** + * Creates an array of the own and inherited enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keysIn(new Foo); + * // => ['a', 'b', 'c'] (iteration order is not guaranteed) + */ + function keysIn(object) { + return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object); + } + + /** + * Converts `value` to a plain object flattening inherited enumerable string + * keyed properties of `value` to own properties of the plain object. + * + * @static + * @memberOf _ + * @since 3.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {Object} Returns the converted plain object. + * @example + * + * function Foo() { + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.assign({ 'a': 1 }, new Foo); + * // => { 'a': 1, 'b': 2 } + * + * _.assign({ 'a': 1 }, _.toPlainObject(new Foo)); + * // => { 'a': 1, 'b': 2, 'c': 3 } + */ + function toPlainObject(value) { + return copyObject(value, keysIn(value)); + } + + /** + * A specialized version of `baseMerge` for arrays and objects which performs + * deep merges and tracks traversed objects enabling objects with circular + * references to be merged. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {string} key The key of the value to merge. + * @param {number} srcIndex The index of `source`. + * @param {Function} mergeFunc The function to merge values. + * @param {Function} [customizer] The function to customize assigned values. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + */ + function baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) { + var objValue = safeGet(object, key), + srcValue = safeGet(source, key), + stacked = stack.get(srcValue); + + if (stacked) { + assignMergeValue(object, key, stacked); + return; + } + var newValue = customizer + ? customizer(objValue, srcValue, (key + ''), object, source, stack) + : undefined; + + var isCommon = newValue === undefined; + + if (isCommon) { + var isArr = isArray$3(srcValue), + isBuff = !isArr && isBuffer$1(srcValue), + isTyped = !isArr && !isBuff && isTypedArray$1(srcValue); + + newValue = srcValue; + if (isArr || isBuff || isTyped) { + if (isArray$3(objValue)) { + newValue = objValue; + } + else if (isArrayLikeObject(objValue)) { + newValue = copyArray(objValue); + } + else if (isBuff) { + isCommon = false; + newValue = cloneBuffer(srcValue, true); + } + else if (isTyped) { + isCommon = false; + newValue = cloneTypedArray(srcValue, true); + } + else { + newValue = []; + } + } + else if (isPlainObject(srcValue) || isArguments$1(srcValue)) { + newValue = objValue; + if (isArguments$1(objValue)) { + newValue = toPlainObject(objValue); + } + else if (!isObject$2(objValue) || isFunction(objValue)) { + newValue = initCloneObject(srcValue); + } + } + else { + isCommon = false; + } + } + if (isCommon) { + // Recursively merge objects and arrays (susceptible to call stack limits). + stack.set(srcValue, newValue); + mergeFunc(newValue, srcValue, srcIndex, customizer, stack); + stack['delete'](srcValue); + } + assignMergeValue(object, key, newValue); + } + + /** + * The base implementation of `_.merge` without support for multiple sources. + * + * @private + * @param {Object} object The destination object. + * @param {Object} source The source object. + * @param {number} srcIndex The index of `source`. + * @param {Function} [customizer] The function to customize merged values. + * @param {Object} [stack] Tracks traversed source values and their merged + * counterparts. + */ + function baseMerge(object, source, srcIndex, customizer, stack) { + if (object === source) { + return; + } + baseFor$1(source, function(srcValue, key) { + stack || (stack = new Stack); + if (isObject$2(srcValue)) { + baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack); + } + else { + var newValue = customizer + ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack) + : undefined; + + if (newValue === undefined) { + newValue = srcValue; + } + assignMergeValue(object, key, newValue); + } + }, keysIn); + } + + /** + * This method returns the first argument it receives. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Util + * @param {*} value Any value. + * @returns {*} Returns `value`. + * @example + * + * var object = { 'a': 1 }; + * + * console.log(_.identity(object) === object); + * // => true + */ + function identity(value) { + return value; + } + + /** + * A faster alternative to `Function#apply`, this function invokes `func` + * with the `this` binding of `thisArg` and the arguments of `args`. + * + * @private + * @param {Function} func The function to invoke. + * @param {*} thisArg The `this` binding of `func`. + * @param {Array} args The arguments to invoke `func` with. + * @returns {*} Returns the result of `func`. + */ + function apply$1(func, thisArg, args) { + switch (args.length) { + case 0: return func.call(thisArg); + case 1: return func.call(thisArg, args[0]); + case 2: return func.call(thisArg, args[0], args[1]); + case 3: return func.call(thisArg, args[0], args[1], args[2]); + } + return func.apply(thisArg, args); + } + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeMax = Math.max; + + /** + * A specialized version of `baseRest` which transforms the rest array. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @param {Function} transform The rest array transform. + * @returns {Function} Returns the new function. + */ + function overRest(func, start, transform) { + start = nativeMax(start === undefined ? (func.length - 1) : start, 0); + return function() { + var args = arguments, + index = -1, + length = nativeMax(args.length - start, 0), + array = Array(length); + + while (++index < length) { + array[index] = args[start + index]; + } + index = -1; + var otherArgs = Array(start + 1); + while (++index < start) { + otherArgs[index] = args[index]; + } + otherArgs[start] = transform(array); + return apply$1(func, this, otherArgs); + }; + } + + /** + * Creates a function that returns `value`. + * + * @static + * @memberOf _ + * @since 2.4.0 + * @category Util + * @param {*} value The value to return from the new function. + * @returns {Function} Returns the new constant function. + * @example + * + * var objects = _.times(2, _.constant({ 'a': 1 })); + * + * console.log(objects); + * // => [{ 'a': 1 }, { 'a': 1 }] + * + * console.log(objects[0] === objects[1]); + * // => true + */ + function constant(value) { + return function() { + return value; + }; + } + + /** + * The base implementation of `setToString` without support for hot loop shorting. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ + var baseSetToString = !defineProperty$1 ? identity : function(func, string) { + return defineProperty$1(func, 'toString', { + 'configurable': true, + 'enumerable': false, + 'value': constant(string), + 'writable': true + }); + }; + + var baseSetToString$1 = baseSetToString; + + /** Used to detect hot functions by number of calls within a span of milliseconds. */ + var HOT_COUNT = 800, + HOT_SPAN = 16; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeNow = Date.now; + + /** + * Creates a function that'll short out and invoke `identity` instead + * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN` + * milliseconds. + * + * @private + * @param {Function} func The function to restrict. + * @returns {Function} Returns the new shortable function. + */ + function shortOut(func) { + var count = 0, + lastCalled = 0; + + return function() { + var stamp = nativeNow(), + remaining = HOT_SPAN - (stamp - lastCalled); + + lastCalled = stamp; + if (remaining > 0) { + if (++count >= HOT_COUNT) { + return arguments[0]; + } + } else { + count = 0; + } + return func.apply(undefined, arguments); + }; + } + + /** + * Sets the `toString` method of `func` to return `string`. + * + * @private + * @param {Function} func The function to modify. + * @param {Function} string The `toString` result. + * @returns {Function} Returns `func`. + */ + var setToString = shortOut(baseSetToString$1); + + var setToString$1 = setToString; + + /** + * The base implementation of `_.rest` which doesn't validate or coerce arguments. + * + * @private + * @param {Function} func The function to apply a rest parameter to. + * @param {number} [start=func.length-1] The start position of the rest parameter. + * @returns {Function} Returns the new function. + */ + function baseRest(func, start) { + return setToString$1(overRest(func, start, identity), func + ''); + } + + /** + * Checks if the given arguments are from an iteratee call. + * + * @private + * @param {*} value The potential iteratee value argument. + * @param {*} index The potential iteratee index or key argument. + * @param {*} object The potential iteratee object argument. + * @returns {boolean} Returns `true` if the arguments are from an iteratee call, + * else `false`. + */ + function isIterateeCall(value, index, object) { + if (!isObject$2(object)) { + return false; + } + var type = typeof index; + if (type == 'number' + ? (isArrayLike(object) && isIndex(index, object.length)) + : (type == 'string' && index in object) + ) { + return eq(object[index], value); + } + return false; + } + + /** + * Creates a function like `_.assign`. + * + * @private + * @param {Function} assigner The function to assign values. + * @returns {Function} Returns the new assigner function. + */ + function createAssigner(assigner) { + return baseRest(function(object, sources) { + var index = -1, + length = sources.length, + customizer = length > 1 ? sources[length - 1] : undefined, + guard = length > 2 ? sources[2] : undefined; + + customizer = (assigner.length > 3 && typeof customizer == 'function') + ? (length--, customizer) + : undefined; + + if (guard && isIterateeCall(sources[0], sources[1], guard)) { + customizer = length < 3 ? undefined : customizer; + length = 1; + } + object = Object(object); + while (++index < length) { + var source = sources[index]; + if (source) { + assigner(object, source, index, customizer); + } + } + return object; + }); + } + + /** + * This method is like `_.merge` except that it accepts `customizer` which + * is invoked to produce the merged values of the destination and source + * properties. If `customizer` returns `undefined`, merging is handled by the + * method instead. The `customizer` is invoked with six arguments: + * (objValue, srcValue, key, object, source, stack). + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Object + * @param {Object} object The destination object. + * @param {...Object} sources The source objects. + * @param {Function} customizer The function to customize assigned values. + * @returns {Object} Returns `object`. + * @example + * + * function customizer(objValue, srcValue) { + * if (_.isArray(objValue)) { + * return objValue.concat(srcValue); + * } + * } + * + * var object = { 'a': [1], 'b': [2] }; + * var other = { 'a': [3], 'b': [4] }; + * + * _.mergeWith(object, other, customizer); + * // => { 'a': [1, 3], 'b': [2, 4] } + */ + var mergeWith = createAssigner(function(object, source, srcIndex, customizer) { + baseMerge(object, source, srcIndex, customizer); + }); + + var mergeWith$1 = mergeWith; + + /** Used to stand-in for `undefined` hash values. */ + var HASH_UNDEFINED = '__lodash_hash_undefined__'; + + /** + * Adds `value` to the array cache. + * + * @private + * @name add + * @memberOf SetCache + * @alias push + * @param {*} value The value to cache. + * @returns {Object} Returns the cache instance. + */ + function setCacheAdd(value) { + this.__data__.set(value, HASH_UNDEFINED); + return this; + } + + /** + * Checks if `value` is in the array cache. + * + * @private + * @name has + * @memberOf SetCache + * @param {*} value The value to search for. + * @returns {number} Returns `true` if `value` is found, else `false`. + */ + function setCacheHas(value) { + return this.__data__.has(value); + } + + /** + * + * Creates an array cache object to store unique values. + * + * @private + * @constructor + * @param {Array} [values] The values to cache. + */ + function SetCache(values) { + var index = -1, + length = values == null ? 0 : values.length; + + this.__data__ = new MapCache; + while (++index < length) { + this.add(values[index]); + } + } + + // Add methods to `SetCache`. + SetCache.prototype.add = SetCache.prototype.push = setCacheAdd; + SetCache.prototype.has = setCacheHas; + + /** + * A specialized version of `_.some` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {boolean} Returns `true` if any element passes the predicate check, + * else `false`. + */ + function arraySome(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length; + + while (++index < length) { + if (predicate(array[index], index, array)) { + return true; + } + } + return false; + } + + /** + * Checks if a `cache` value for `key` exists. + * + * @private + * @param {Object} cache The cache to query. + * @param {string} key The key of the entry to check. + * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`. + */ + function cacheHas(cache, key) { + return cache.has(key); + } + + /** Used to compose bitmasks for value comparisons. */ + var COMPARE_PARTIAL_FLAG$3 = 1, + COMPARE_UNORDERED_FLAG$1 = 2; + + /** + * A specialized version of `baseIsEqualDeep` for arrays with support for + * partial deep comparisons. + * + * @private + * @param {Array} array The array to compare. + * @param {Array} other The other array to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `array` and `other` objects. + * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`. + */ + function equalArrays(array, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG$3, + arrLength = array.length, + othLength = other.length; + + if (arrLength != othLength && !(isPartial && othLength > arrLength)) { + return false; + } + // Check that cyclic values are equal. + var arrStacked = stack.get(array); + var othStacked = stack.get(other); + if (arrStacked && othStacked) { + return arrStacked == other && othStacked == array; + } + var index = -1, + result = true, + seen = (bitmask & COMPARE_UNORDERED_FLAG$1) ? new SetCache : undefined; + + stack.set(array, other); + stack.set(other, array); + + // Ignore non-index properties. + while (++index < arrLength) { + var arrValue = array[index], + othValue = other[index]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, arrValue, index, other, array, stack) + : customizer(arrValue, othValue, index, array, other, stack); + } + if (compared !== undefined) { + if (compared) { + continue; + } + result = false; + break; + } + // Recursively compare arrays (susceptible to call stack limits). + if (seen) { + if (!arraySome(other, function(othValue, othIndex) { + if (!cacheHas(seen, othIndex) && + (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) { + return seen.push(othIndex); + } + })) { + result = false; + break; + } + } else if (!( + arrValue === othValue || + equalFunc(arrValue, othValue, bitmask, customizer, stack) + )) { + result = false; + break; + } + } + stack['delete'](array); + stack['delete'](other); + return result; + } + + /** + * Converts `map` to its key-value pairs. + * + * @private + * @param {Object} map The map to convert. + * @returns {Array} Returns the key-value pairs. + */ + function mapToArray(map) { + var index = -1, + result = Array(map.size); + + map.forEach(function(value, key) { + result[++index] = [key, value]; + }); + return result; + } + + /** + * Converts `set` to an array of its values. + * + * @private + * @param {Object} set The set to convert. + * @returns {Array} Returns the values. + */ + function setToArray(set) { + var index = -1, + result = Array(set.size); + + set.forEach(function(value) { + result[++index] = value; + }); + return result; + } + + /** Used to compose bitmasks for value comparisons. */ + var COMPARE_PARTIAL_FLAG$2 = 1, + COMPARE_UNORDERED_FLAG = 2; + + /** `Object#toString` result references. */ + var boolTag = '[object Boolean]', + dateTag = '[object Date]', + errorTag = '[object Error]', + mapTag$1 = '[object Map]', + numberTag = '[object Number]', + regexpTag = '[object RegExp]', + setTag$1 = '[object Set]', + stringTag$1 = '[object String]', + symbolTag$1 = '[object Symbol]'; + + var arrayBufferTag = '[object ArrayBuffer]', + dataViewTag$1 = '[object DataView]'; + + /** Used to convert symbols to primitives and strings. */ + var symbolProto$1 = Symbol$2 ? Symbol$2.prototype : undefined, + symbolValueOf = symbolProto$1 ? symbolProto$1.valueOf : undefined; + + /** + * A specialized version of `baseIsEqualDeep` for comparing objects of + * the same `toStringTag`. + * + * **Note:** This function only supports comparing values with tags of + * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {string} tag The `toStringTag` of the objects to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) { + switch (tag) { + case dataViewTag$1: + if ((object.byteLength != other.byteLength) || + (object.byteOffset != other.byteOffset)) { + return false; + } + object = object.buffer; + other = other.buffer; + + case arrayBufferTag: + if ((object.byteLength != other.byteLength) || + !equalFunc(new Uint8Array$2(object), new Uint8Array$2(other))) { + return false; + } + return true; + + case boolTag: + case dateTag: + case numberTag: + // Coerce booleans to `1` or `0` and dates to milliseconds. + // Invalid dates are coerced to `NaN`. + return eq(+object, +other); + + case errorTag: + return object.name == other.name && object.message == other.message; + + case regexpTag: + case stringTag$1: + // Coerce regexes to strings and treat strings, primitives and objects, + // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring + // for more details. + return object == (other + ''); + + case mapTag$1: + var convert = mapToArray; + + case setTag$1: + var isPartial = bitmask & COMPARE_PARTIAL_FLAG$2; + convert || (convert = setToArray); + + if (object.size != other.size && !isPartial) { + return false; + } + // Assume cyclic values are equal. + var stacked = stack.get(object); + if (stacked) { + return stacked == other; + } + bitmask |= COMPARE_UNORDERED_FLAG; + + // Recursively compare objects (susceptible to call stack limits). + stack.set(object, other); + var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack); + stack['delete'](object); + return result; + + case symbolTag$1: + if (symbolValueOf) { + return symbolValueOf.call(object) == symbolValueOf.call(other); + } + } + return false; + } + + /** + * Appends the elements of `values` to `array`. + * + * @private + * @param {Array} array The array to modify. + * @param {Array} values The values to append. + * @returns {Array} Returns `array`. + */ + function arrayPush(array, values) { + var index = -1, + length = values.length, + offset = array.length; + + while (++index < length) { + array[offset + index] = values[index]; + } + return array; + } + + /** + * The base implementation of `getAllKeys` and `getAllKeysIn` which uses + * `keysFunc` and `symbolsFunc` to get the enumerable property names and + * symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Function} keysFunc The function to get the keys of `object`. + * @param {Function} symbolsFunc The function to get the symbols of `object`. + * @returns {Array} Returns the array of property names and symbols. + */ + function baseGetAllKeys(object, keysFunc, symbolsFunc) { + var result = keysFunc(object); + return isArray$3(object) ? result : arrayPush(result, symbolsFunc(object)); + } + + /** + * A specialized version of `_.filter` for arrays without support for + * iteratee shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} predicate The function invoked per iteration. + * @returns {Array} Returns the new filtered array. + */ + function arrayFilter(array, predicate) { + var index = -1, + length = array == null ? 0 : array.length, + resIndex = 0, + result = []; + + while (++index < length) { + var value = array[index]; + if (predicate(value, index, array)) { + result[resIndex++] = value; + } + } + return result; + } + + /** + * This method returns a new empty array. + * + * @static + * @memberOf _ + * @since 4.13.0 + * @category Util + * @returns {Array} Returns the new empty array. + * @example + * + * var arrays = _.times(2, _.stubArray); + * + * console.log(arrays); + * // => [[], []] + * + * console.log(arrays[0] === arrays[1]); + * // => false + */ + function stubArray() { + return []; + } + + /** Used for built-in method references. */ + var objectProto$4 = Object.prototype; + + /** Built-in value references. */ + var propertyIsEnumerable = objectProto$4.propertyIsEnumerable; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeGetSymbols = Object.getOwnPropertySymbols; + + /** + * Creates an array of the own enumerable symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of symbols. + */ + var getSymbols = !nativeGetSymbols ? stubArray : function(object) { + if (object == null) { + return []; + } + object = Object(object); + return arrayFilter(nativeGetSymbols(object), function(symbol) { + return propertyIsEnumerable.call(object, symbol); + }); + }; + + var getSymbols$1 = getSymbols; + + /* Built-in method references for those with the same name as other `lodash` methods. */ + var nativeKeys = overArg(Object.keys, Object); + + var nativeKeys$1 = nativeKeys; + + /** Used for built-in method references. */ + var objectProto$3 = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$3 = objectProto$3.hasOwnProperty; + + /** + * The base implementation of `_.keys` which doesn't treat sparse arrays as dense. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + */ + function baseKeys(object) { + if (!isPrototype(object)) { + return nativeKeys$1(object); + } + var result = []; + for (var key in Object(object)) { + if (hasOwnProperty$3.call(object, key) && key != 'constructor') { + result.push(key); + } + } + return result; + } + + /** + * Creates an array of the own enumerable property names of `object`. + * + * **Note:** Non-object values are coerced to objects. See the + * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys) + * for more details. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names. + * @example + * + * function Foo() { + * this.a = 1; + * this.b = 2; + * } + * + * Foo.prototype.c = 3; + * + * _.keys(new Foo); + * // => ['a', 'b'] (iteration order is not guaranteed) + * + * _.keys('hi'); + * // => ['0', '1'] + */ + function keys(object) { + return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object); + } + + /** + * Creates an array of own enumerable property names and symbols of `object`. + * + * @private + * @param {Object} object The object to query. + * @returns {Array} Returns the array of property names and symbols. + */ + function getAllKeys(object) { + return baseGetAllKeys(object, keys, getSymbols$1); + } + + /** Used to compose bitmasks for value comparisons. */ + var COMPARE_PARTIAL_FLAG$1 = 1; + + /** Used for built-in method references. */ + var objectProto$2 = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$2 = objectProto$2.hasOwnProperty; + + /** + * A specialized version of `baseIsEqualDeep` for objects with support for + * partial deep comparisons. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} stack Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function equalObjects(object, other, bitmask, customizer, equalFunc, stack) { + var isPartial = bitmask & COMPARE_PARTIAL_FLAG$1, + objProps = getAllKeys(object), + objLength = objProps.length, + othProps = getAllKeys(other), + othLength = othProps.length; + + if (objLength != othLength && !isPartial) { + return false; + } + var index = objLength; + while (index--) { + var key = objProps[index]; + if (!(isPartial ? key in other : hasOwnProperty$2.call(other, key))) { + return false; + } + } + // Check that cyclic values are equal. + var objStacked = stack.get(object); + var othStacked = stack.get(other); + if (objStacked && othStacked) { + return objStacked == other && othStacked == object; + } + var result = true; + stack.set(object, other); + stack.set(other, object); + + var skipCtor = isPartial; + while (++index < objLength) { + key = objProps[index]; + var objValue = object[key], + othValue = other[key]; + + if (customizer) { + var compared = isPartial + ? customizer(othValue, objValue, key, other, object, stack) + : customizer(objValue, othValue, key, object, other, stack); + } + // Recursively compare objects (susceptible to call stack limits). + if (!(compared === undefined + ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack)) + : compared + )) { + result = false; + break; + } + skipCtor || (skipCtor = key == 'constructor'); + } + if (result && !skipCtor) { + var objCtor = object.constructor, + othCtor = other.constructor; + + // Non `Object` object instances with different constructors are not equal. + if (objCtor != othCtor && + ('constructor' in object && 'constructor' in other) && + !(typeof objCtor == 'function' && objCtor instanceof objCtor && + typeof othCtor == 'function' && othCtor instanceof othCtor)) { + result = false; + } + } + stack['delete'](object); + stack['delete'](other); + return result; + } + + /* Built-in method references that are verified to be native. */ + var DataView = getNative(root$1, 'DataView'); + + var DataView$1 = DataView; + + /* Built-in method references that are verified to be native. */ + var Promise$1 = getNative(root$1, 'Promise'); + + var Promise$2 = Promise$1; + + /* Built-in method references that are verified to be native. */ + var Set$1 = getNative(root$1, 'Set'); + + var Set$2 = Set$1; + + /* Built-in method references that are verified to be native. */ + var WeakMap = getNative(root$1, 'WeakMap'); + + var WeakMap$1 = WeakMap; + + /** `Object#toString` result references. */ + var mapTag = '[object Map]', + objectTag$1 = '[object Object]', + promiseTag = '[object Promise]', + setTag = '[object Set]', + weakMapTag = '[object WeakMap]'; + + var dataViewTag = '[object DataView]'; + + /** Used to detect maps, sets, and weakmaps. */ + var dataViewCtorString = toSource(DataView$1), + mapCtorString = toSource(Map$2), + promiseCtorString = toSource(Promise$2), + setCtorString = toSource(Set$2), + weakMapCtorString = toSource(WeakMap$1); + + /** + * Gets the `toStringTag` of `value`. + * + * @private + * @param {*} value The value to query. + * @returns {string} Returns the `toStringTag`. + */ + var getTag = baseGetTag; + + // Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6. + if ((DataView$1 && getTag(new DataView$1(new ArrayBuffer(1))) != dataViewTag) || + (Map$2 && getTag(new Map$2) != mapTag) || + (Promise$2 && getTag(Promise$2.resolve()) != promiseTag) || + (Set$2 && getTag(new Set$2) != setTag) || + (WeakMap$1 && getTag(new WeakMap$1) != weakMapTag)) { + getTag = function(value) { + var result = baseGetTag(value), + Ctor = result == objectTag$1 ? value.constructor : undefined, + ctorString = Ctor ? toSource(Ctor) : ''; + + if (ctorString) { + switch (ctorString) { + case dataViewCtorString: return dataViewTag; + case mapCtorString: return mapTag; + case promiseCtorString: return promiseTag; + case setCtorString: return setTag; + case weakMapCtorString: return weakMapTag; + } + } + return result; + }; + } + + var getTag$1 = getTag; + + /** Used to compose bitmasks for value comparisons. */ + var COMPARE_PARTIAL_FLAG = 1; + + /** `Object#toString` result references. */ + var argsTag = '[object Arguments]', + arrayTag = '[object Array]', + objectTag = '[object Object]'; + + /** Used for built-in method references. */ + var objectProto$1 = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty$1 = objectProto$1.hasOwnProperty; + + /** + * A specialized version of `baseIsEqual` for arrays and objects which performs + * deep comparisons and tracks traversed objects enabling objects with circular + * references to be compared. + * + * @private + * @param {Object} object The object to compare. + * @param {Object} other The other object to compare. + * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details. + * @param {Function} customizer The function to customize comparisons. + * @param {Function} equalFunc The function to determine equivalents of values. + * @param {Object} [stack] Tracks traversed `object` and `other` objects. + * @returns {boolean} Returns `true` if the objects are equivalent, else `false`. + */ + function baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) { + var objIsArr = isArray$3(object), + othIsArr = isArray$3(other), + objTag = objIsArr ? arrayTag : getTag$1(object), + othTag = othIsArr ? arrayTag : getTag$1(other); + + objTag = objTag == argsTag ? objectTag : objTag; + othTag = othTag == argsTag ? objectTag : othTag; + + var objIsObj = objTag == objectTag, + othIsObj = othTag == objectTag, + isSameTag = objTag == othTag; + + if (isSameTag && isBuffer$1(object)) { + if (!isBuffer$1(other)) { + return false; + } + objIsArr = true; + objIsObj = false; + } + if (isSameTag && !objIsObj) { + stack || (stack = new Stack); + return (objIsArr || isTypedArray$1(object)) + ? equalArrays(object, other, bitmask, customizer, equalFunc, stack) + : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack); + } + if (!(bitmask & COMPARE_PARTIAL_FLAG)) { + var objIsWrapped = objIsObj && hasOwnProperty$1.call(object, '__wrapped__'), + othIsWrapped = othIsObj && hasOwnProperty$1.call(other, '__wrapped__'); + + if (objIsWrapped || othIsWrapped) { + var objUnwrapped = objIsWrapped ? object.value() : object, + othUnwrapped = othIsWrapped ? other.value() : other; + + stack || (stack = new Stack); + return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack); + } + } + if (!isSameTag) { + return false; + } + stack || (stack = new Stack); + return equalObjects(object, other, bitmask, customizer, equalFunc, stack); + } + + /** + * The base implementation of `_.isEqual` which supports partial comparisons + * and tracks traversed objects. + * + * @private + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @param {boolean} bitmask The bitmask flags. + * 1 - Unordered comparison + * 2 - Partial comparison + * @param {Function} [customizer] The function to customize comparisons. + * @param {Object} [stack] Tracks traversed `value` and `other` objects. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + */ + function baseIsEqual(value, other, bitmask, customizer, stack) { + if (value === other) { + return true; + } + if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) { + return value !== value && other !== other; + } + return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack); + } + + /** + * Performs a deep comparison between two values to determine if they are + * equivalent. + * + * **Note:** This method supports comparing arrays, array buffers, booleans, + * date objects, error objects, maps, numbers, `Object` objects, regexes, + * sets, strings, symbols, and typed arrays. `Object` objects are compared + * by their own, not inherited, enumerable properties. Functions and DOM + * nodes are compared by strict equality, i.e. `===`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Lang + * @param {*} value The value to compare. + * @param {*} other The other value to compare. + * @returns {boolean} Returns `true` if the values are equivalent, else `false`. + * @example + * + * var object = { 'a': 1 }; + * var other = { 'a': 1 }; + * + * _.isEqual(object, other); + * // => true + * + * object === other; + * // => false + */ + function isEqual(value, other) { + return baseIsEqual(value, other); + } + + /** Used for built-in method references. */ + var objectProto = Object.prototype; + + /** Used to check objects for own properties. */ + var hasOwnProperty = objectProto.hasOwnProperty; + + /** + * The base implementation of `_.has` without support for deep paths. + * + * @private + * @param {Object} [object] The object to query. + * @param {Array|string} key The key to check. + * @returns {boolean} Returns `true` if `key` exists, else `false`. + */ + function baseHas(object, key) { + return object != null && hasOwnProperty.call(object, key); + } + + /** `Object#toString` result references. */ + var symbolTag = '[object Symbol]'; + + /** + * Checks if `value` is classified as a `Symbol` primitive or object. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a symbol, else `false`. + * @example + * + * _.isSymbol(Symbol.iterator); + * // => true + * + * _.isSymbol('abc'); + * // => false + */ + function isSymbol(value) { + return typeof value == 'symbol' || + (isObjectLike(value) && baseGetTag(value) == symbolTag); + } + + /** Used to match property names within property paths. */ + var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, + reIsPlainProp = /^\w*$/; + + /** + * Checks if `value` is a property name and not a property path. + * + * @private + * @param {*} value The value to check. + * @param {Object} [object] The object to query keys on. + * @returns {boolean} Returns `true` if `value` is a property name, else `false`. + */ + function isKey(value, object) { + if (isArray$3(value)) { + return false; + } + var type = typeof value; + if (type == 'number' || type == 'symbol' || type == 'boolean' || + value == null || isSymbol(value)) { + return true; + } + return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || + (object != null && value in Object(object)); + } + + /** Error message constants. */ + var FUNC_ERROR_TEXT = 'Expected a function'; + + /** + * Creates a function that memoizes the result of `func`. If `resolver` is + * provided, it determines the cache key for storing the result based on the + * arguments provided to the memoized function. By default, the first argument + * provided to the memoized function is used as the map cache key. The `func` + * is invoked with the `this` binding of the memoized function. + * + * **Note:** The cache is exposed as the `cache` property on the memoized + * function. Its creation may be customized by replacing the `_.memoize.Cache` + * constructor with one whose instances implement the + * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object) + * method interface of `clear`, `delete`, `get`, `has`, and `set`. + * + * @static + * @memberOf _ + * @since 0.1.0 + * @category Function + * @param {Function} func The function to have its output memoized. + * @param {Function} [resolver] The function to resolve the cache key. + * @returns {Function} Returns the new memoized function. + * @example + * + * var object = { 'a': 1, 'b': 2 }; + * var other = { 'c': 3, 'd': 4 }; + * + * var values = _.memoize(_.values); + * values(object); + * // => [1, 2] + * + * values(other); + * // => [3, 4] + * + * object.a = 2; + * values(object); + * // => [1, 2] + * + * // Modify the result cache. + * values.cache.set(object, ['a', 'b']); + * values(object); + * // => ['a', 'b'] + * + * // Replace `_.memoize.Cache`. + * _.memoize.Cache = WeakMap; + */ + function memoize(func, resolver) { + if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) { + throw new TypeError(FUNC_ERROR_TEXT); + } + var memoized = function() { + var args = arguments, + key = resolver ? resolver.apply(this, args) : args[0], + cache = memoized.cache; + + if (cache.has(key)) { + return cache.get(key); + } + var result = func.apply(this, args); + memoized.cache = cache.set(key, result) || cache; + return result; + }; + memoized.cache = new (memoize.Cache || MapCache); + return memoized; + } + + // Expose `MapCache`. + memoize.Cache = MapCache; + + /** Used as the maximum memoize cache size. */ + var MAX_MEMOIZE_SIZE = 500; + + /** + * A specialized version of `_.memoize` which clears the memoized function's + * cache when it exceeds `MAX_MEMOIZE_SIZE`. + * + * @private + * @param {Function} func The function to have its output memoized. + * @returns {Function} Returns the new memoized function. + */ + function memoizeCapped(func) { + var result = memoize(func, function(key) { + if (cache.size === MAX_MEMOIZE_SIZE) { + cache.clear(); + } + return key; + }); + + var cache = result.cache; + return result; + } + + /** Used to match property names within property paths. */ + var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g; + + /** Used to match backslashes in property paths. */ + var reEscapeChar = /\\(\\)?/g; + + /** + * Converts `string` to a property path array. + * + * @private + * @param {string} string The string to convert. + * @returns {Array} Returns the property path array. + */ + var stringToPath = memoizeCapped(function(string) { + var result = []; + if (string.charCodeAt(0) === 46 /* . */) { + result.push(''); + } + string.replace(rePropName, function(match, number, quote, subString) { + result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match)); + }); + return result; + }); + + var stringToPath$1 = stringToPath; + + /** + * A specialized version of `_.map` for arrays without support for iteratee + * shorthands. + * + * @private + * @param {Array} [array] The array to iterate over. + * @param {Function} iteratee The function invoked per iteration. + * @returns {Array} Returns the new mapped array. + */ + function arrayMap(array, iteratee) { + var index = -1, + length = array == null ? 0 : array.length, + result = Array(length); + + while (++index < length) { + result[index] = iteratee(array[index], index, array); + } + return result; + } + + /** Used as references for various `Number` constants. */ + var INFINITY$1 = 1 / 0; + + /** Used to convert symbols to primitives and strings. */ + var symbolProto = Symbol$2 ? Symbol$2.prototype : undefined, + symbolToString = symbolProto ? symbolProto.toString : undefined; + + /** + * The base implementation of `_.toString` which doesn't convert nullish + * values to empty strings. + * + * @private + * @param {*} value The value to process. + * @returns {string} Returns the string. + */ + function baseToString(value) { + // Exit early for strings to avoid a performance hit in some environments. + if (typeof value == 'string') { + return value; + } + if (isArray$3(value)) { + // Recursively convert values (susceptible to call stack limits). + return arrayMap(value, baseToString) + ''; + } + if (isSymbol(value)) { + return symbolToString ? symbolToString.call(value) : ''; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY$1) ? '-0' : result; + } + + /** + * Converts `value` to a string. An empty string is returned for `null` + * and `undefined` values. The sign of `-0` is preserved. + * + * @static + * @memberOf _ + * @since 4.0.0 + * @category Lang + * @param {*} value The value to convert. + * @returns {string} Returns the converted string. + * @example + * + * _.toString(null); + * // => '' + * + * _.toString(-0); + * // => '-0' + * + * _.toString([1, 2, 3]); + * // => '1,2,3' + */ + function toString$3(value) { + return value == null ? '' : baseToString(value); + } + + /** + * Casts `value` to a path array if it's not one. + * + * @private + * @param {*} value The value to inspect. + * @param {Object} [object] The object to query keys on. + * @returns {Array} Returns the cast property path array. + */ + function castPath(value, object) { + if (isArray$3(value)) { + return value; + } + return isKey(value, object) ? [value] : stringToPath$1(toString$3(value)); + } + + /** Used as references for various `Number` constants. */ + var INFINITY = 1 / 0; + + /** + * Converts `value` to a string key if it's not a string or symbol. + * + * @private + * @param {*} value The value to inspect. + * @returns {string|symbol} Returns the key. + */ + function toKey(value) { + if (typeof value == 'string' || isSymbol(value)) { + return value; + } + var result = (value + ''); + return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result; + } + + /** + * Checks if `path` exists on `object`. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @param {Function} hasFunc The function to check properties. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + */ + function hasPath(object, path, hasFunc) { + path = castPath(path, object); + + var index = -1, + length = path.length, + result = false; + + while (++index < length) { + var key = toKey(path[index]); + if (!(result = object != null && hasFunc(object, key))) { + break; + } + object = object[key]; + } + if (result || ++index != length) { + return result; + } + length = object == null ? 0 : object.length; + return !!length && isLength(length) && isIndex(key, length) && + (isArray$3(object) || isArguments$1(object)); + } + + /** + * Checks if `path` is a direct property of `object`. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path to check. + * @returns {boolean} Returns `true` if `path` exists, else `false`. + * @example + * + * var object = { 'a': { 'b': 2 } }; + * var other = _.create({ 'a': _.create({ 'b': 2 }) }); + * + * _.has(object, 'a'); + * // => true + * + * _.has(object, 'a.b'); + * // => true + * + * _.has(object, ['a', 'b']); + * // => true + * + * _.has(other, 'a'); + * // => false + */ + function has(object, path) { + return object != null && hasPath(object, path, baseHas); + } + + /** + * The base implementation of `_.get` without support for default values. + * + * @private + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @returns {*} Returns the resolved value. + */ + function baseGet(object, path) { + path = castPath(path, object); + + var index = 0, + length = path.length; + + while (object != null && index < length) { + object = object[toKey(path[index++])]; + } + return (index && index == length) ? object : undefined; + } + + /** + * Gets the value at `path` of `object`. If the resolved value is + * `undefined`, the `defaultValue` is returned in its place. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to query. + * @param {Array|string} path The path of the property to get. + * @param {*} [defaultValue] The value returned for `undefined` resolved values. + * @returns {*} Returns the resolved value. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.get(object, 'a[0].b.c'); + * // => 3 + * + * _.get(object, ['a', '0', 'b', 'c']); + * // => 3 + * + * _.get(object, 'a.b.c', 'default'); + * // => 'default' + */ + function get(object, path, defaultValue) { + var result = object == null ? undefined : baseGet(object, path); + return result === undefined ? defaultValue : result; + } + + /** + * The base implementation of `_.set`. + * + * @private + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @param {Function} [customizer] The function to customize path creation. + * @returns {Object} Returns `object`. + */ + function baseSet(object, path, value, customizer) { + if (!isObject$2(object)) { + return object; + } + path = castPath(path, object); + + var index = -1, + length = path.length, + lastIndex = length - 1, + nested = object; + + while (nested != null && ++index < length) { + var key = toKey(path[index]), + newValue = value; + + if (key === '__proto__' || key === 'constructor' || key === 'prototype') { + return object; + } + + if (index != lastIndex) { + var objValue = nested[key]; + newValue = customizer ? customizer(objValue, key, nested) : undefined; + if (newValue === undefined) { + newValue = isObject$2(objValue) + ? objValue + : (isIndex(path[index + 1]) ? [] : {}); + } + } + assignValue(nested, key, newValue); + nested = nested[key]; + } + return object; + } + + /** + * Sets the value at `path` of `object`. If a portion of `path` doesn't exist, + * it's created. Arrays are created for missing index properties while objects + * are created for all other missing properties. Use `_.setWith` to customize + * `path` creation. + * + * **Note:** This method mutates `object`. + * + * @static + * @memberOf _ + * @since 3.7.0 + * @category Object + * @param {Object} object The object to modify. + * @param {Array|string} path The path of the property to set. + * @param {*} value The value to set. + * @returns {Object} Returns `object`. + * @example + * + * var object = { 'a': [{ 'b': { 'c': 3 } }] }; + * + * _.set(object, 'a[0].b.c', 4); + * console.log(object.a[0].b.c); + * // => 4 + * + * _.set(object, ['x', '0', 'y', 'z'], 5); + * console.log(object.x[0].y.z); + * // => 5 + */ + function set(object, path, value) { + return object == null ? object : baseSet(object, path, value); + } + + /** `Object#toString` result references. */ + var stringTag = '[object String]'; + + /** + * Checks if `value` is classified as a `String` primitive or object. + * + * @static + * @since 0.1.0 + * @memberOf _ + * @category Lang + * @param {*} value The value to check. + * @returns {boolean} Returns `true` if `value` is a string, else `false`. + * @example + * + * _.isString('abc'); + * // => true + * + * _.isString(1); + * // => false + */ + function isString(value) { + return typeof value == 'string' || + (!isArray$3(value) && isObjectLike(value) && baseGetTag(value) == stringTag); + } + + var OptionsPreProcessors = { + range: function range(value) { + return Math.max(+value, 1); + }, + 'date.highlight': function dateHighlight(args) { + return castArray(args); + }, + 'subDomain.label': function subDomainLabel(value) { + return ( + // eslint-disable-next-line + isString(value) && value !== '' || isFunction(value) ? value : null + ); + } + }; + + var Options = /*#__PURE__*/function () { + function Options() { + var processors = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : OptionsPreProcessors; + _classCallCheck(this, Options); + this.preProcessors = processors; + this.options = { + // selector string of the container to append the graph to + // Accept any string value accepted by document.querySelector or CSS3 + // or an Element object + itemSelector: OPTIONS_DEFAULT_ITEM_SELECTOR, + // Number of domain to display on the graph + range: OPTIONS_DEFAULT_RANGE, + domain: { + type: OPTIONS_DEFAULT_DOMAIN_TYPE, + // Space between each domain, in pixel + gutter: 4, + padding: [0, 0, 0, 0], + // Whether to enable dynamic domain size + // The width/height on a domain depends on the number of + // subDomains items count + dynamicDimension: true, + // Whether to show most recent date first + sort: 'asc', + label: { + // Formatting of the domain label + // @default: undefined, will use the formatting + // according to domain type + // Accept any string accepted by dayjs.format() + // or a function + // + // Refer to https://day.js.org/docs/en/display/format + // for list of accepted string tokens used by dayjs.format() + text: undefined, + // valid: top, right, bottom, left + position: 'bottom', + // Valid are the direct svg values: start, middle, end + textAlign: 'middle', + // By default, there is no margin/padding around the label + offset: { + x: 0, + y: 0 + }, + rotate: null, + // Used only on vertical orientation + width: 100, + // Used only on horizontal orientation + height: 25 + } + }, + subDomain: { + type: OPTIONS_DEFAULT_SUBDOMAIN_TYPE, + // Width of each subDomain cell, in pixel + width: OPTIONS_DEFAULT_SUBDOMAIN_WIDTH, + // Height of each subDomain cell, in pixel + height: OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT, + // Space between each subDomain cell, in pixel + gutter: OPTIONS_DEFAULT_SUBDOMAIN_GUTTER, + // Radius of each subDomain cell, in pixel + radius: OPTIONS_DEFAULT_SUBDOMAIN_RADIUS, + // Formatting of the text inside each subDomain cell + // @default: null, no text + // Accept any string accepted by dayjs.format() + // or a function + // + // Refer to https://day.js.org/docs/en/display/format + // for list of accepted string tokens used by dayjs.format() + label: null, + color: undefined, + sort: 'asc' + }, + date: { + // Start date of the graph + // @default now + start: new Date(), + min: undefined, + max: undefined, + // List of dates to highlight + // Valid values: + // - []: don't highlight anything + // - an array of Date objects: highlight the specified dates + highlight: [], + locale: OPTIONS_DEFAULT_LOCALE, + timezone: undefined + }, + // Calendar orientation + // false: display domains side by side + // true : display domains one under the other + verticalOrientation: false, + data: { + // Data source + // URL, where to fetch the original datas + source: '', + // Data type + // Default: json + type: 'json', + requestInit: {}, + // keyname of the time property + x: '', + // keyname of the value property + y: '', + // Grouping function of the values + groupY: 'sum', + defaultValue: null + }, + scale: undefined, + // Animation duration, in ms + animationDuration: OPTIONS_DEFAULT_ANIMATION_DURATION, + // Theme mode: dark/light + theme: OPTIONS_DEFAULT_THEME, + // Internally used options, do not edit not set + x: { + domainHorizontalLabelWidth: 0, + domainVerticalLabelHeight: 0 + } + }; + } + /** + * Set a new value for an option, only if unchanged + * @param {string} key Name of the option + * @param {any} value Value of the option + * @return {boolean} Whether the option have been changed + */ + _createClass(Options, [{ + key: "set", + value: function set$1(key, value) { + if (!has(this.options, key) || isEqual(get(this.options, key), value)) { + return false; + } + set(this.options, key, has(this.preProcessors, key) ? get(this.preProcessors, key)(value) : value); + return true; + } + }, { + key: "init", + value: function init(opts) { + var _this = this; + this.options = Object.assign({}, mergeWith$1(this.options, opts, function (_, srcValue) { + return Array.isArray(srcValue) ? srcValue : undefined; + })); + var options = this.options; + Object.keys(this.preProcessors).forEach(function (key) { + set(options, key, get(_this.preProcessors, key)(get(options, key))); + }); + if (typeof options.scale === 'undefined') { + this.initScale(); + } + options.x.domainVerticalLabelHeight = options.domain.label.height; + // When the label is affecting the height + if (options.domain.label.position === 'top' || options.domain.label.position === 'bottom') { + options.x.domainHorizontalLabelWidth = 0; + } else { + options.x.domainVerticalLabelHeight = 0; + options.x.domainHorizontalLabelWidth = options.domain.label.width; + } + if (options.domain.label.text === null || options.domain.label.text === '') { + options.x.domainVerticalLabelHeight = 0; + options.x.domainHorizontalLabelWidth = 0; + } + } + }, { + key: "initScale", + value: function initScale() { + this.options.scale = { + color: { + scheme: SCALE_BASE_COLOR_SCHEME, + type: SCALE_BASE_COLOR_TYPE, + domain: SCALE_BASE_COLOR_DOMAIN + } + }; + } + }]); + return Options; + }(); + + var anObject$2 = anObject$f; + + // `RegExp.prototype.flags` getter implementation + // https://tc39.es/ecma262/#sec-get-regexp.prototype.flags + var regexpFlags$1 = function () { + var that = anObject$2(this); + var result = ''; + if (that.hasIndices) result += 'd'; + if (that.global) result += 'g'; + if (that.ignoreCase) result += 'i'; + if (that.multiline) result += 'm'; + if (that.dotAll) result += 's'; + if (that.unicode) result += 'u'; + if (that.unicodeSets) result += 'v'; + if (that.sticky) result += 'y'; + return result; + }; + + var fails$4 = fails$u; + var global$3 = global$n; + + // babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError + var $RegExp$2 = global$3.RegExp; + + var UNSUPPORTED_Y$1 = fails$4(function () { + var re = $RegExp$2('a', 'y'); + re.lastIndex = 2; + return re.exec('abcd') !== null; + }); + + // UC Browser bug + // https://github.com/zloirock/core-js/issues/1008 + var MISSED_STICKY = UNSUPPORTED_Y$1 || fails$4(function () { + return !$RegExp$2('a', 'y').sticky; + }); + + var BROKEN_CARET = UNSUPPORTED_Y$1 || fails$4(function () { + // https://bugzilla.mozilla.org/show_bug.cgi?id=773687 + var re = $RegExp$2('^r', 'gy'); + re.lastIndex = 2; + return re.exec('str') !== null; + }); + + var regexpStickyHelpers = { + BROKEN_CARET: BROKEN_CARET, + MISSED_STICKY: MISSED_STICKY, + UNSUPPORTED_Y: UNSUPPORTED_Y$1 + }; + + var fails$3 = fails$u; + var global$2 = global$n; + + // babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError + var $RegExp$1 = global$2.RegExp; + + var regexpUnsupportedDotAll = fails$3(function () { + var re = $RegExp$1('.', 's'); + return !(re.dotAll && re.test('\n') && re.flags === 's'); + }); + + var fails$2 = fails$u; + var global$1 = global$n; + + // babel-minify and Closure Compiler transpiles RegExp('(?b)', 'g') -> /(?b)/g and it causes SyntaxError + var $RegExp = global$1.RegExp; + + var regexpUnsupportedNcg = fails$2(function () { + var re = $RegExp('(?b)', 'g'); + return re.exec('b').groups.a !== 'b' || + 'b'.replace(re, '$c') !== 'bc'; + }); + + /* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */ + /* eslint-disable regexp/no-useless-quantifier -- testing */ + var call$2 = functionCall; + var uncurryThis$5 = functionUncurryThis; + var toString$2 = toString$9; + var regexpFlags = regexpFlags$1; + var stickyHelpers = regexpStickyHelpers; + var shared = sharedExports; + var create = objectCreate$1; + var getInternalState = internalState.get; + var UNSUPPORTED_DOT_ALL = regexpUnsupportedDotAll; + var UNSUPPORTED_NCG = regexpUnsupportedNcg; + + var nativeReplace = shared('native-string-replace', String.prototype.replace); + var nativeExec = RegExp.prototype.exec; + var patchedExec = nativeExec; + var charAt$2 = uncurryThis$5(''.charAt); + var indexOf = uncurryThis$5(''.indexOf); + var replace$1 = uncurryThis$5(''.replace); + var stringSlice$2 = uncurryThis$5(''.slice); + + var UPDATES_LAST_INDEX_WRONG = (function () { + var re1 = /a/; + var re2 = /b*/g; + call$2(nativeExec, re1, 'a'); + call$2(nativeExec, re2, 'a'); + return re1.lastIndex !== 0 || re2.lastIndex !== 0; + })(); + + var UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET; + + // nonparticipating capturing group, copied from es5-shim's String#split patch. + var NPCG_INCLUDED = /()??/.exec('')[1] !== undefined; + + var PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG; + + if (PATCH) { + patchedExec = function exec(string) { + var re = this; + var state = getInternalState(re); + var str = toString$2(string); + var raw = state.raw; + var result, reCopy, lastIndex, match, i, object, group; + + if (raw) { + raw.lastIndex = re.lastIndex; + result = call$2(patchedExec, raw, str); + re.lastIndex = raw.lastIndex; + return result; + } + + var groups = state.groups; + var sticky = UNSUPPORTED_Y && re.sticky; + var flags = call$2(regexpFlags, re); + var source = re.source; + var charsAdded = 0; + var strCopy = str; + + if (sticky) { + flags = replace$1(flags, 'y', ''); + if (indexOf(flags, 'g') === -1) { + flags += 'g'; + } + + strCopy = stringSlice$2(str, re.lastIndex); + // Support anchored sticky behavior. + if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt$2(str, re.lastIndex - 1) !== '\n')) { + source = '(?: ' + source + ')'; + strCopy = ' ' + strCopy; + charsAdded++; + } + // ^(? + rx + ) is needed, in combination with some str slicing, to + // simulate the 'y' flag. + reCopy = new RegExp('^(?:' + source + ')', flags); + } + + if (NPCG_INCLUDED) { + reCopy = new RegExp('^' + source + '$(?!\\s)', flags); + } + if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex; + + match = call$2(nativeExec, sticky ? reCopy : re, strCopy); + + if (sticky) { + if (match) { + match.input = stringSlice$2(match.input, charsAdded); + match[0] = stringSlice$2(match[0], charsAdded); + match.index = re.lastIndex; + re.lastIndex += match[0].length; + } else re.lastIndex = 0; + } else if (UPDATES_LAST_INDEX_WRONG && match) { + re.lastIndex = re.global ? match.index + match[0].length : lastIndex; + } + if (NPCG_INCLUDED && match && match.length > 1) { + // Fix browsers whose `exec` methods don't consistently return `undefined` + // for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/ + call$2(nativeReplace, match[0], reCopy, function () { + for (i = 1; i < arguments.length - 2; i++) { + if (arguments[i] === undefined) match[i] = undefined; + } + }); + } + + if (match && groups) { + match.groups = object = create(null); + for (i = 0; i < groups.length; i++) { + group = groups[i]; + object[group[0]] = match[group[1]]; + } + } + + return match; + }; + } + + var regexpExec$2 = patchedExec; + + var $$1 = _export; + var exec = regexpExec$2; + + // `RegExp.prototype.exec` method + // https://tc39.es/ecma262/#sec-regexp.prototype.exec + $$1({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, { + exec: exec + }); + + // TODO: Remove from `core-js@4` since it's moved to entry points + + var uncurryThis$4 = functionUncurryThisClause; + var defineBuiltIn = defineBuiltIn$9; + var regexpExec$1 = regexpExec$2; + var fails$1 = fails$u; + var wellKnownSymbol$1 = wellKnownSymbol$m; + var createNonEnumerableProperty = createNonEnumerableProperty$6; + + var SPECIES = wellKnownSymbol$1('species'); + var RegExpPrototype = RegExp.prototype; + + var fixRegexpWellKnownSymbolLogic = function (KEY, exec, FORCED, SHAM) { + var SYMBOL = wellKnownSymbol$1(KEY); + + var DELEGATES_TO_SYMBOL = !fails$1(function () { + // String methods call symbol-named RegEp methods + var O = {}; + O[SYMBOL] = function () { return 7; }; + return ''[KEY](O) !== 7; + }); + + var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails$1(function () { + // Symbol-named RegExp methods call .exec + var execCalled = false; + var re = /a/; + + if (KEY === 'split') { + // We can't use real regex here since it causes deoptimization + // and serious performance degradation in V8 + // https://github.com/zloirock/core-js/issues/306 + re = {}; + // RegExp[@@split] doesn't call the regex's exec method, but first creates + // a new one. We need to return the patched regex when creating the new one. + re.constructor = {}; + re.constructor[SPECIES] = function () { return re; }; + re.flags = ''; + re[SYMBOL] = /./[SYMBOL]; + } + + re.exec = function () { + execCalled = true; + return null; + }; + + re[SYMBOL](''); + return !execCalled; + }); + + if ( + !DELEGATES_TO_SYMBOL || + !DELEGATES_TO_EXEC || + FORCED + ) { + var uncurriedNativeRegExpMethod = uncurryThis$4(/./[SYMBOL]); + var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) { + var uncurriedNativeMethod = uncurryThis$4(nativeMethod); + var $exec = regexp.exec; + if ($exec === regexpExec$1 || $exec === RegExpPrototype.exec) { + if (DELEGATES_TO_SYMBOL && !forceStringMethod) { + // The native String method already delegates to @@method (this + // polyfilled function), leasing to infinite recursion. + // We avoid it by directly calling the native @@method method. + return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) }; + } + return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) }; + } + return { done: false }; + }); + + defineBuiltIn(String.prototype, KEY, methods[0]); + defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]); + } + + if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true); + }; + + var charAt$1 = stringMultibyte.charAt; + + // `AdvanceStringIndex` abstract operation + // https://tc39.es/ecma262/#sec-advancestringindex + var advanceStringIndex$1 = function (S, index, unicode) { + return index + (unicode ? charAt$1(S, index).length : 1); + }; + + var uncurryThis$3 = functionUncurryThis; + var toObject = toObject$a; + + var floor = Math.floor; + var charAt = uncurryThis$3(''.charAt); + var replace = uncurryThis$3(''.replace); + var stringSlice$1 = uncurryThis$3(''.slice); + // eslint-disable-next-line redos/no-vulnerable -- safe + var SUBSTITUTION_SYMBOLS = /\$([$&'`]|\d{1,2}|<[^>]*>)/g; + var SUBSTITUTION_SYMBOLS_NO_NAMED = /\$([$&'`]|\d{1,2})/g; + + // `GetSubstitution` abstract operation + // https://tc39.es/ecma262/#sec-getsubstitution + var getSubstitution$1 = function (matched, str, position, captures, namedCaptures, replacement) { + var tailPos = position + matched.length; + var m = captures.length; + var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED; + if (namedCaptures !== undefined) { + namedCaptures = toObject(namedCaptures); + symbols = SUBSTITUTION_SYMBOLS; + } + return replace(replacement, symbols, function (match, ch) { + var capture; + switch (charAt(ch, 0)) { + case '$': return '$'; + case '&': return matched; + case '`': return stringSlice$1(str, 0, position); + case "'": return stringSlice$1(str, tailPos); + case '<': + capture = namedCaptures[stringSlice$1(ch, 1, -1)]; + break; + default: // \d\d? + var n = +ch; + if (n === 0) return match; + if (n > m) { + var f = floor(n / 10); + if (f === 0) return match; + if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1); + return match; + } + capture = captures[n - 1]; + } + return capture === undefined ? '' : capture; + }); + }; + + var call$1 = functionCall; + var anObject$1 = anObject$f; + var isCallable$1 = isCallable$o; + var classof = classofRaw$2; + var regexpExec = regexpExec$2; + + var $TypeError = TypeError; + + // `RegExpExec` abstract operation + // https://tc39.es/ecma262/#sec-regexpexec + var regexpExecAbstract = function (R, S) { + var exec = R.exec; + if (isCallable$1(exec)) { + var result = call$1(exec, R, S); + if (result !== null) anObject$1(result); + return result; + } + if (classof(R) === 'RegExp') return call$1(regexpExec, R, S); + throw new $TypeError('RegExp#exec called on incompatible receiver'); + }; + + var apply = functionApply; + var call = functionCall; + var uncurryThis$2 = functionUncurryThis; + var fixRegExpWellKnownSymbolLogic = fixRegexpWellKnownSymbolLogic; + var fails = fails$u; + var anObject = anObject$f; + var isCallable = isCallable$o; + var isNullOrUndefined = isNullOrUndefined$8; + var toIntegerOrInfinity = toIntegerOrInfinity$4; + var toLength = toLength$3; + var toString$1 = toString$9; + var requireObjectCoercible$1 = requireObjectCoercible$7; + var advanceStringIndex = advanceStringIndex$1; + var getMethod = getMethod$4; + var getSubstitution = getSubstitution$1; + var regExpExec$1 = regexpExecAbstract; + var wellKnownSymbol = wellKnownSymbol$m; + + var REPLACE = wellKnownSymbol('replace'); + var max = Math.max; + var min = Math.min; + var concat = uncurryThis$2([].concat); + var push = uncurryThis$2([].push); + var stringIndexOf$1 = uncurryThis$2(''.indexOf); + var stringSlice = uncurryThis$2(''.slice); + + var maybeToString = function (it) { + return it === undefined ? it : String(it); + }; + + // IE <= 11 replaces $0 with the whole match, as if it was $& + // https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0 + var REPLACE_KEEPS_$0 = (function () { + // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing + return 'a'.replace(/./, '$0') === '$0'; + })(); + + // Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string + var REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () { + if (/./[REPLACE]) { + return /./[REPLACE]('a', '$0') === ''; + } + return false; + })(); + + var REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () { + var re = /./; + re.exec = function () { + var result = []; + result.groups = { a: '7' }; + return result; + }; + // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive + return ''.replace(re, '$') !== '7'; + }); + + // @@replace logic + fixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) { + var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0'; + + return [ + // `String.prototype.replace` method + // https://tc39.es/ecma262/#sec-string.prototype.replace + function replace(searchValue, replaceValue) { + var O = requireObjectCoercible$1(this); + var replacer = isNullOrUndefined(searchValue) ? undefined : getMethod(searchValue, REPLACE); + return replacer + ? call(replacer, searchValue, O, replaceValue) + : call(nativeReplace, toString$1(O), searchValue, replaceValue); + }, + // `RegExp.prototype[@@replace]` method + // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace + function (string, replaceValue) { + var rx = anObject(this); + var S = toString$1(string); + + if ( + typeof replaceValue == 'string' && + stringIndexOf$1(replaceValue, UNSAFE_SUBSTITUTE) === -1 && + stringIndexOf$1(replaceValue, '$<') === -1 + ) { + var res = maybeCallNative(nativeReplace, rx, S, replaceValue); + if (res.done) return res.value; + } + + var functionalReplace = isCallable(replaceValue); + if (!functionalReplace) replaceValue = toString$1(replaceValue); + + var global = rx.global; + var fullUnicode; + if (global) { + fullUnicode = rx.unicode; + rx.lastIndex = 0; + } + + var results = []; + var result; + while (true) { + result = regExpExec$1(rx, S); + if (result === null) break; + + push(results, result); + if (!global) break; + + var matchStr = toString$1(result[0]); + if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode); + } + + var accumulatedResult = ''; + var nextSourcePosition = 0; + for (var i = 0; i < results.length; i++) { + result = results[i]; + + var matched = toString$1(result[0]); + var position = max(min(toIntegerOrInfinity(result.index), S.length), 0); + var captures = []; + var replacement; + // NOTE: This is equivalent to + // captures = result.slice(1).map(maybeToString) + // but for some reason `nativeSlice.call(result, 1, result.length)` (called in + // the slice polyfill when slicing native arrays) "doesn't work" in safari 9 and + // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it. + for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j])); + var namedCaptures = result.groups; + if (functionalReplace) { + var replacerArgs = concat([matched], captures, position, S); + if (namedCaptures !== undefined) push(replacerArgs, namedCaptures); + replacement = toString$1(apply(replaceValue, undefined, replacerArgs)); + } else { + replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue); + } + if (position >= nextSourcePosition) { + accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement; + nextSourcePosition = position + matched.length; + } + } + + return accumulatedResult + stringSlice(S, nextSourcePosition); + } + ]; + }, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE); + + var _DataFetcher_instances, _DataFetcher_fetch; + var DataFetcher = /*#__PURE__*/function () { + function DataFetcher(calendar) { + _classCallCheck(this, DataFetcher); + _DataFetcher_instances.add(this); + this.calendar = calendar; + } + /** + * Fetch and interpret data from the datasource + * + * @param {string|object} source + * @param {number} startTimestamp + * @param {number} endTimestamp + * + * @return {Promize} A promise, that will return the final data when resolved + */ + _createClass(DataFetcher, [{ + key: "getDatas", + value: function getDatas(source, startTimestamp, endTimestamp) { + return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() { + var d; + return _regeneratorRuntime().wrap(function _callee$(_context) { + while (1) switch (_context.prev = _context.next) { + case 0: + if (!(typeof source === 'string' && source.length > 0)) { + _context.next = 2; + break; + } + return _context.abrupt("return", __classPrivateFieldGet(this, _DataFetcher_instances, "m", _DataFetcher_fetch).call(this, source, startTimestamp, endTimestamp)); + case 2: + d = []; + if (Array.isArray(source)) { + d = source; + } + return _context.abrupt("return", new Promise(function (resolve) { + resolve(d); + })); + case 5: + case "end": + return _context.stop(); + } + }, _callee, this); + })); + } + }, { + key: "parseURI", + value: function parseURI(str, startTimestamp, endTimestamp) { + var _this = this; + var newUri = str.replace(/\{\{start=(.*?)\}\}/g, function (_, format) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + _this.calendar.dateHelper.date(startTimestamp).format(format) + ); + }); + newUri = newUri.replace(/\{\{end=(.*?)\}\}/g, function (_, format) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + _this.calendar.dateHelper.date(endTimestamp).format(format) + ); + }); + return newUri; + } + }]); + return DataFetcher; + }(); + _DataFetcher_instances = new WeakSet(), _DataFetcher_fetch = function _DataFetcher_fetch(source, startTimestamp, endTimestamp) { + var _this$calendar$option = this.calendar.options.options.data, + type = _this$calendar$option.type, + requestInit = _this$calendar$option.requestInit; + var url = this.parseURI(source, startTimestamp, endTimestamp); + switch (type) { + case 'json': + return d3Fetch.json(url, requestInit); + case 'csv': + return d3Fetch.csv(url, requestInit); + case 'tsv': + return d3Fetch.dsv('\t', url, requestInit); + case 'txt': + return d3Fetch.text(url, requestInit); + default: + return new Promise(function (resolve) { + resolve([]); + }); + } + }; + + var DESCRIPTORS = descriptors; + var FUNCTION_NAME_EXISTS = functionName.EXISTS; + var uncurryThis$1 = functionUncurryThis; + var defineBuiltInAccessor = defineBuiltInAccessor$3; + + var FunctionPrototype = Function.prototype; + var functionToString = uncurryThis$1(FunctionPrototype.toString); + var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; + var regExpExec = uncurryThis$1(nameRE.exec); + var NAME = 'name'; + + // Function instances `.name` property + // https://tc39.es/ecma262/#sec-function-instances-name + if (DESCRIPTORS && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor(FunctionPrototype, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); + } + + var dayjs_min = {exports: {}}; + + (function (module, exports) { + !function(t,e){module.exports=e();}(commonjsGlobal,(function(){var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",s="minute",u="hour",a="day",o="week",c="month",f="quarter",h="year",d="date",l="Invalid Date",$=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,y=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function(t){var e=["th","st","nd","rd"],n=t%100;return "["+t+(e[(n-20)%10]||e[n]||e[0])+"]"}},m=function(t,e,n){var r=String(t);return !r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return (e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()1)return t(u[0])}else {var a=e.name;D[a]=e,i=a;}return !r&&i&&(g=i),i||!r&&g},O=function(t,e){if(S(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},b=v;b.l=w,b.i=S,b.w=function(t,e){return O(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=w(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[p]=!0;}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(b.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.init();},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds();},m.$utils=function(){return b},m.isValid=function(){return !(this.$d.toString()===l)},m.isSame=function(t,e){var n=O(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return O(t)25){var f=r(this).startOf(t).add(1,t).date(n),s=r(this).endOf(e);if(f.isBefore(s))return 1}var a=r(this).startOf(t).date(n).startOf(e).subtract(1,"millisecond"),o=this.diff(a,e,!0);return o<0?r(this).startOf("week").week():Math.ceil(o)},f.weeks=function(e){return void 0===e&&(e=null),this.week(e)};}})); + } (weekOfYear$1)); + + var weekOfYearExports = weekOfYear$1.exports; + var weekOfYear = /*@__PURE__*/getDefaultExportFromCjs(weekOfYearExports); + + var dayOfYear$1 = {exports: {}}; + + (function (module, exports) { + !function(e,t){module.exports=t();}(commonjsGlobal,(function(){return function(e,t,n){t.prototype.dayOfYear=function(e){var t=Math.round((n(this).startOf("day")-n(this).startOf("year"))/864e5)+1;return null==e?t:this.add(e-t,"day")};}})); + } (dayOfYear$1)); + + var dayOfYearExports = dayOfYear$1.exports; + var dayOfYear = /*@__PURE__*/getDefaultExportFromCjs(dayOfYearExports); + + var weekday$1 = {exports: {}}; + + (function (module, exports) { + !function(e,t){module.exports=t();}(commonjsGlobal,(function(){return function(e,t){t.prototype.weekday=function(e){var t=this.$locale().weekStart||0,i=this.$W,n=(i0&&(n=n[0]);t=(n=n.filter((function(e){return e})))[0];for(var i=1;i4&&(o+=7),n.add(o,e));return r.diff(u,"week")+1},d.isoWeekday=function(e){return this.$utils().u(e)?this.day()||7:this.day(this.day()%7?e:e-7)};var n=d.startOf;d.startOf=function(e,t){var i=this.$utils(),s=!!i.u(t)||t;return "isoweek"===i.p(e)?s?this.date(this.date()-(this.isoWeekday()-1)).startOf("day"):this.date(this.date()-1-(this.isoWeekday()-1)+7).endOf("day"):n.bind(this)(e,t)};}})); + } (isoWeek$1)); + + var isoWeekExports = isoWeek$1.exports; + var isoWeek = /*@__PURE__*/getDefaultExportFromCjs(isoWeekExports); + + var isLeapYear$1 = {exports: {}}; + + (function (module, exports) { + !function(e,t){module.exports=t();}(commonjsGlobal,(function(){return function(e,t){t.prototype.isLeapYear=function(){return this.$y%4==0&&this.$y%100!=0||this.$y%400==0};}})); + } (isLeapYear$1)); + + var isLeapYearExports = isLeapYear$1.exports; + var isLeapYear = /*@__PURE__*/getDefaultExportFromCjs(isLeapYearExports); + + var advancedFormat$1 = {exports: {}}; + + (function (module, exports) { + !function(e,t){module.exports=t();}(commonjsGlobal,(function(){return function(e,t){var r=t.prototype,n=r.format;r.format=function(e){var t=this,r=this.$locale();if(!this.isValid())return n.bind(this)(e);var s=this.$utils(),a=(e||"YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g,(function(e){switch(e){case"Q":return Math.ceil((t.$M+1)/3);case"Do":return r.ordinal(t.$D);case"gggg":return t.weekYear();case"GGGG":return t.isoWeekYear();case"wo":return r.ordinal(t.week(),"W");case"w":case"ww":return s.s(t.week(),"w"===e?1:2,"0");case"W":case"WW":return s.s(t.isoWeek(),"W"===e?1:2,"0");case"k":case"kk":return s.s(String(0===t.$H?24:t.$H),"k"===e?1:2,"0");case"X":return Math.floor(t.$d.getTime()/1e3);case"x":return t.$d.getTime();case"z":return "["+t.offsetName()+"]";case"zzz":return "["+t.offsetName("long")+"]";default:return e}}));return n.bind(this)(a)};}})); + } (advancedFormat$1)); + + var advancedFormatExports = advancedFormat$1.exports; + var advancedFormat = /*@__PURE__*/getDefaultExportFromCjs(advancedFormatExports); + + var utc$1 = {exports: {}}; + + (function (module, exports) { + !function(t,i){module.exports=i();}(commonjsGlobal,(function(){var t="minute",i=/[+-]\d\d(?::?\d\d)?/g,e=/([+-]|\d\d)/g;return function(s,f,n){var u=f.prototype;n.utc=function(t){var i={date:t,utc:!0,args:arguments};return new f(i)},u.utc=function(i){var e=n(this.toDate(),{locale:this.$L,utc:!0});return i?e.add(this.utcOffset(),t):e},u.local=function(){return n(this.toDate(),{locale:this.$L,utc:!1})};var o=u.parse;u.parse=function(t){t.utc&&(this.$u=!0),this.$utils().u(t.$offset)||(this.$offset=t.$offset),o.call(this,t);};var r=u.init;u.init=function(){if(this.$u){var t=this.$d;this.$y=t.getUTCFullYear(),this.$M=t.getUTCMonth(),this.$D=t.getUTCDate(),this.$W=t.getUTCDay(),this.$H=t.getUTCHours(),this.$m=t.getUTCMinutes(),this.$s=t.getUTCSeconds(),this.$ms=t.getUTCMilliseconds();}else r.call(this);};var a=u.utcOffset;u.utcOffset=function(s,f){var n=this.$utils().u;if(n(s))return this.$u?0:n(this.$offset)?a.call(this):this.$offset;if("string"==typeof s&&(s=function(t){void 0===t&&(t="");var s=t.match(i);if(!s)return null;var f=(""+s[0]).match(e)||["-",0,0],n=f[0],u=60*+f[1]+ +f[2];return 0===u?0:"+"===n?u:-u}(s),null===s))return this;var u=Math.abs(s)<=16?60*s:s,o=this;if(f)return o.$offset=u,o.$u=0===s,o;if(0!==s){var r=this.$u?this.toDate().getTimezoneOffset():-1*this.utcOffset();(o=this.local().add(u+r,t)).$offset=u,o.$x.$localOffset=r;}else o=this.utc();return o};var h=u.format;u.format=function(t){var i=t||(this.$u?"YYYY-MM-DDTHH:mm:ss[Z]":"");return h.call(this,i)},u.valueOf=function(){var t=this.$utils().u(this.$offset)?0:this.$offset+(this.$x.$localOffset||this.$d.getTimezoneOffset());return this.$d.valueOf()-6e4*t},u.isUTC=function(){return !!this.$u},u.toISOString=function(){return this.toDate().toISOString()},u.toString=function(){return this.toDate().toUTCString()};var l=u.toDate;u.toDate=function(t){return "s"===t&&this.$offset?n(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate():l.call(this)};var c=u.diff;u.diff=function(t,i,e){if(t&&this.$u===t.$u)return c.call(this,t,i,e);var s=this.local(),f=n(t).local();return c.call(s,f,i,e)};}})); + } (utc$1)); + + var utcExports = utc$1.exports; + var utc = /*@__PURE__*/getDefaultExportFromCjs(utcExports); + + var timezone$1 = {exports: {}}; + + (function (module, exports) { + !function(t,e){module.exports=e();}(commonjsGlobal,(function(){var t={year:0,month:1,day:2,hour:3,minute:4,second:5},e={};return function(n,i,o){var r,a=function(t,n,i){void 0===i&&(i={});var o=new Date(t),r=function(t,n){void 0===n&&(n={});var i=n.timeZoneName||"short",o=t+"|"+i,r=e[o];return r||(r=new Intl.DateTimeFormat("en-US",{hour12:!1,timeZone:t,year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",second:"2-digit",timeZoneName:i}),e[o]=r),r}(n,i);return r.formatToParts(o)},u=function(e,n){for(var i=a(e,n),r=[],u=0;u=0&&(r[c]=parseInt(m,10));}var d=r[3],l=24===d?0:d,h=r[0]+"-"+r[1]+"-"+r[2]+" "+l+":"+r[4]+":"+r[5]+":000",v=+e;return (o.utc(h).valueOf()-(v-=v%1e3))/6e4},f=i.prototype;f.tz=function(t,e){void 0===t&&(t=r);var n=this.utcOffset(),i=this.toDate(),a=i.toLocaleString("en-US",{timeZone:t}),u=Math.round((i-new Date(a))/1e3/60),f=o(a,{locale:this.$L}).$set("millisecond",this.$ms).utcOffset(15*-Math.round(i.getTimezoneOffset()/15)-u,!0);if(e){var s=f.utcOffset();f=f.add(n-s,"minute");}return f.$x.$timezone=t,f},f.offsetName=function(t){var e=this.$x.$timezone||o.tz.guess(),n=a(this.valueOf(),e,{timeZoneName:t}).find((function(t){return "timezonename"===t.type.toLowerCase()}));return n&&n.value};var s=f.startOf;f.startOf=function(t,e){if(!this.$x||!this.$x.$timezone)return s.call(this,t,e);var n=o(this.format("YYYY-MM-DD HH:mm:ss:SSS"),{locale:this.$L});return s.call(n,t,e).tz(this.$x.$timezone,!0)},o.tz=function(t,e,n){var i=n&&e,a=n||e||r,f=u(+o(),a);if("string"!=typeof t)return o(t).tz(a);var s=function(t,e,n){var i=t-60*e*1e3,o=u(i,n);if(e===o)return [i,e];var r=u(i-=60*(o-e)*1e3,n);return o===r?[i,o]:[t-60*Math.min(o,r)*1e3,Math.max(o,r)]}(o.utc(t,i).valueOf(),f,a),m=s[0],c=s[1],d=o(m).utcOffset(c);return d.$x.$timezone=a,d},o.tz.guess=function(){return Intl.DateTimeFormat().resolvedOptions().timeZone},o.tz.setDefault=function(t){r=t;};}})); + } (timezone$1)); + + var timezoneExports = timezone$1.exports; + var timezone = /*@__PURE__*/getDefaultExportFromCjs(timezoneExports); + + var localeData$1 = {exports: {}}; + + (function (module, exports) { + !function(n,e){module.exports=e();}(commonjsGlobal,(function(){return function(n,e,t){var r=e.prototype,o=function(n){return n&&(n.indexOf?n:n.s)},u=function(n,e,t,r,u){var i=n.name?n:n.$locale(),a=o(i[e]),s=o(i[t]),f=a||s.map((function(n){return n.slice(0,r)}));if(!u)return f;var d=i.weekStart;return f.map((function(n,e){return f[(e+(d||0))%7]}))},i=function(){return t.Ls[t.locale()]},a=function(n,e){return n.formats[e]||function(n){return n.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(n,e,t){return e||t.slice(1)}))}(n.formats[e.toUpperCase()])},s=function(){var n=this;return {months:function(e){return e?e.format("MMMM"):u(n,"months")},monthsShort:function(e){return e?e.format("MMM"):u(n,"monthsShort","months",3)},firstDayOfWeek:function(){return n.$locale().weekStart||0},weekdays:function(e){return e?e.format("dddd"):u(n,"weekdays")},weekdaysMin:function(e){return e?e.format("dd"):u(n,"weekdaysMin","weekdays",2)},weekdaysShort:function(e){return e?e.format("ddd"):u(n,"weekdaysShort","weekdays",3)},longDateFormat:function(e){return a(n.$locale(),e)},meridiem:this.$locale().meridiem,ordinal:this.$locale().ordinal}};r.localeData=function(){return s.bind(this)()},t.localeData=function(){var n=i();return {firstDayOfWeek:function(){return n.weekStart||0},weekdays:function(){return t.weekdays()},weekdaysShort:function(){return t.weekdaysShort()},weekdaysMin:function(){return t.weekdaysMin()},months:function(){return t.months()},monthsShort:function(){return t.monthsShort()},longDateFormat:function(e){return a(n,e)},meridiem:n.meridiem,ordinal:n.ordinal}},t.months=function(){return u(i(),"months")},t.monthsShort=function(){return u(i(),"monthsShort","months",3)},t.weekdays=function(n){return u(i(),"weekdays",null,null,n)},t.weekdaysShort=function(n){return u(i(),"weekdaysShort","weekdays",3,n)},t.weekdaysMin=function(n){return u(i(),"weekdaysMin","weekdays",2,n)};}})); + } (localeData$1)); + + var localeDataExports = localeData$1.exports; + var localeData = /*@__PURE__*/getDefaultExportFromCjs(localeDataExports); + + var localizedFormat$1 = {exports: {}}; + + (function (module, exports) { + !function(e,t){module.exports=t();}(commonjsGlobal,(function(){var e={LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"};return function(t,o,n){var r=o.prototype,i=r.format;n.en.formats=e,r.format=function(t){void 0===t&&(t="YYYY-MM-DDTHH:mm:ssZ");var o=this.$locale().formats,n=function(t,o){return t.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g,(function(t,n,r){var i=r&&r.toUpperCase();return n||o[r]||e[r]||o[i].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(e,t,o){return t||o.slice(1)}))}))}(t,void 0===o?{}:o);return i.call(this,n)};}})); + } (localizedFormat$1)); + + var localizedFormatExports = localizedFormat$1.exports; + var localizedFormat = /*@__PURE__*/getDefaultExportFromCjs(localizedFormatExports); + + var updateLocale$1 = {exports: {}}; + + (function (module, exports) { + !function(e,n){module.exports=n();}(commonjsGlobal,(function(){return function(e,n,t){t.updateLocale=function(e,n){var o=t.Ls[e];if(o)return (n?Object.keys(n):[]).forEach((function(e){o[e]=n[e];})),o};}})); + } (updateLocale$1)); + + var updateLocaleExports = updateLocale$1.exports; + var updateLocale = /*@__PURE__*/getDefaultExportFromCjs(updateLocaleExports); + + dayjs.extend(weekOfYear); + dayjs.extend(isoWeeksInYear); + dayjs.extend(isoWeek); + dayjs.extend(isLeapYear); + dayjs.extend(dayOfYear); + dayjs.extend(weekday); + dayjs.extend(minMax); + dayjs.extend(advancedFormat); + dayjs.extend(utc); + dayjs.extend(timezone); + dayjs.extend(localeData); + dayjs.extend(localizedFormat); + dayjs.extend(updateLocale); + var DEFAULT_LOCALE = 'en'; + var DateHelper = /*#__PURE__*/function () { + function DateHelper() { + _classCallCheck(this, DateHelper); + var _a; + this.locale = DEFAULT_LOCALE; + this.timezone = dayjs.tz.guess(); + if ((typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object') { + (_a = window).dayjs || (_a.dayjs = dayjs); + } + } + _createClass(DateHelper, [{ + key: "setup", + value: function setup(_ref) { + var options = _ref.options; + return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() { + var userLocale, locale; + return _regeneratorRuntime().wrap(function _callee$(_context) { + while (1) switch (_context.prev = _context.next) { + case 0: + this.timezone = options.date.timezone || dayjs.tz.guess(); + userLocale = options.date.locale; + if (!(typeof userLocale === 'string' && userLocale !== DEFAULT_LOCALE)) { + _context.next = 17; + break; + } + if (!((typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object')) { + _context.next = 12; + break; + } + _context.t0 = window["dayjs_locale_".concat(userLocale)]; + if (_context.t0) { + _context.next = 9; + break; + } + _context.next = 8; + return this.loadBrowserLocale(userLocale); + case 8: + _context.t0 = _context.sent; + case 9: + locale = _context.t0; + _context.next = 15; + break; + case 12: + _context.next = 14; + return this.loadNodeLocale(userLocale); + case 14: + locale = _context.sent; + case 15: + dayjs.locale(userLocale); + this.locale = locale; + case 17: + if (_typeof(userLocale) === 'object') { + if (userLocale.hasOwnProperty('name')) { + dayjs.locale(userLocale.name, userLocale); + this.locale = userLocale; + } else { + this.locale = dayjs.updateLocale(DEFAULT_LOCALE, userLocale); + } + } + case 18: + case "end": + return _context.stop(); + } + }, _callee, this); + })); + } + // eslint-disable-next-line class-methods-use-this + }, { + key: "extend", + value: function extend(dayjsPlugin) { + return dayjs.extend(dayjsPlugin); + } + /** + * Return the week number, relative to its month + * + * @param {number|Date} d Date or timestamp in milliseconds + * @returns {number} The week number, relative to the month [0-5] + */ + }, { + key: "getMonthWeekNumber", + value: function getMonthWeekNumber(d) { + var dayjsDate = this.date(d); + var date = dayjsDate.startOf('day'); + var endOfWeek = dayjsDate.startOf('month').endOf('week'); + if (date <= endOfWeek) { + return 1; + } + return Math.ceil(date.diff(endOfWeek, 'weeks', true)) + 1; + } + /** + * Return the number of weeks in the given month + * + * As there is no fixed standard to specify which month a partial week should + * belongs to, the ISO week date standard is used, where: + * - the first week of the month should have at least 4 days + * + * @see https://en.wikipedia.org/wiki/ISO_week_date + * + * @param {Timestamp | dayjs.Dayjs} d Datejs object or timestamp + * @return {number} The number of weeks + */ + }, { + key: "getWeeksCountInMonth", + value: function getWeeksCountInMonth(d) { + var pivotDate = this.date(d); + return this.getLastWeekOfMonth(pivotDate).diff(this.getFirstWeekOfMonth(pivotDate), 'week') + 1; + } + /** + * Return the start of the first week of the month + * + * @see getWeeksCountInMonth() about standard warning + * @return {dayjs.Dayjs} A dayjs object representing the start of the + * first week + */ + }, { + key: "getFirstWeekOfMonth", + value: function getFirstWeekOfMonth(d) { + var startOfMonth = this.date(d).startOf('month'); + var startOfFirstWeek = startOfMonth.startOf('week'); + if (startOfMonth.weekday() > 4) { + startOfFirstWeek = startOfFirstWeek.add(1, 'week'); + } + return startOfFirstWeek; + } + /** + * Return the end of the last week of the month + * + * @see getWeeksCountInMonth() about standard warning + * @return {dayjs.Dayjs} A dayjs object representing the end of the last week + */ + }, { + key: "getLastWeekOfMonth", + value: function getLastWeekOfMonth(d) { + var endOfMonth = this.date(d).endOf('month'); + var endOfLastWeek = endOfMonth.endOf('week'); + if (endOfMonth.weekday() < 4) { + endOfLastWeek = endOfLastWeek.subtract(1, 'week'); + } + return endOfLastWeek; + } + }, { + key: "date", + value: function date() { + var d = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date(); + if (dayjs.isDayjs(d)) { + return d; + } + return dayjs(d).tz(this.timezone).utcOffset(0).locale(this.locale); + } + }, { + key: "format", + value: function format(timestamp, formatter) { + if (typeof formatter === 'function') { + for (var _len = arguments.length, args = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) { + args[_key - 2] = arguments[_key]; + } + return formatter.apply(void 0, [timestamp].concat(args)); + } + if (typeof formatter === 'string') { + return this.date(timestamp).format(formatter); + } + return null; + } + /** + * Return an array of time interval + * + * @param {number|Date} date A random date included in the wanted interval + * @param {number|Date} range Length of the wanted interval, or a stop date. + * @param {boolean} range Whether the end date should be excluded + * from the result + * @returns {Array} Array of unix timestamp, in milliseconds + */ + }, { + key: "intervals", + value: function intervals(interval, date, range) { + var excludeEnd = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true; + var start = this.date(date); + var end; + if (typeof range === 'number') { + end = start.add(range, interval); + } else if (dayjs.isDayjs(range)) { + end = range; + } else { + end = this.date(range); + } + start = start.startOf(interval); + end = end.startOf(interval); + var pivot = dayjs.min(start, end); + end = dayjs.max(start, end); + var result = []; + if (!excludeEnd) { + end = end.add(1, 'second'); + } + do { + result.push(+pivot); + pivot = pivot.add(1, interval); + } while (pivot < end); + return result; + } + // this function will work cross-browser for loading scripts asynchronously + // eslint-disable-next-line class-methods-use-this + }, { + key: "loadBrowserLocale", + value: function loadBrowserLocale(userLocale) { + return new Promise(function (resolve, reject) { + var s = document.createElement('script'); + s.type = 'text/javascript'; + s.async = true; + s.src = "https://cdn.jsdelivr.net/npm/dayjs@1/locale/".concat(userLocale, ".js"); + s.onerror = function (err) { + reject(err); + }; + s.onload = function () { + resolve(window["dayjs_locale_".concat(userLocale)]); + }; + document.head.appendChild(s); + }); + } + // eslint-disable-next-line class-methods-use-this + }, { + key: "loadNodeLocale", + value: function loadNodeLocale(userLocale) { + return import("dayjs/locale/".concat(userLocale, ".js")); + } + }]); + return DateHelper; + }(); + + var $ = _export; + var uncurryThis = functionUncurryThis; + var notARegExp = notARegexp; + var requireObjectCoercible = requireObjectCoercible$7; + var toString = toString$9; + var correctIsRegExpLogic = correctIsRegexpLogic; + + var stringIndexOf = uncurryThis(''.indexOf); + + // `String.prototype.includes` method + // https://tc39.es/ecma262/#sec-string.prototype.includes + $({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, { + includes: function includes(searchString /* , position = 0 */) { + return !!~stringIndexOf( + toString(requireObjectCoercible(this)), + toString(notARegExp(searchString)), + arguments.length > 1 ? arguments[1] : undefined + ); + } + }); + + var ALLOWED_DATA_TYPES = ['json', 'csv', 'tsv', 'txt']; + /** + * Ensure that critical options are valid + * + * @throw {Error} on critical invalid options + * @return {boolean} Returns true when there is not critical errors + */ + function validate(templateCollection, _ref) { + var domain = _ref.domain, + subDomain = _ref.subDomain, + data = _ref.data; + var domainType = domain.type; + var subDomainType = subDomain.type; + if (!templateCollection.has(domainType)) { + throw new Error("'".concat(domainType, "' is not a valid domain type'")); + } + if (!templateCollection.has(subDomainType)) { + throw new Error("'".concat(subDomainType, "' is not a valid subDomain type'")); + } + if (data.type && !ALLOWED_DATA_TYPES.includes(data.type)) { + throw new Error("The data type '".concat(data.type, "' is not valid data type")); + } + if (!(templateCollection.get(subDomainType).allowedDomainType || []).includes(domainType)) { + throw new Error("The subDomain.type '".concat(subDomainType, "' can not be used together ") + "with the domain type ".concat(domainType)); + } + return true; + } + + var collection = collection$3; + var collectionStrong = collectionStrong$2; + + // `Set` constructor + // https://tc39.es/ecma262/#sec-set-objects + collection('Set', function (init) { + return function Set() { return init(this, arguments.length ? arguments[0] : undefined); }; + }, collectionStrong); + + function createPlugin(Creator, calendar) { + return new Creator(calendar); + } + function extractPluginName(PluginClass, options) { + return "".concat(new PluginClass().name).concat((options === null || options === void 0 ? void 0 : options.key) || ''); + } + var PluginManager = /*#__PURE__*/function () { + function PluginManager(calendar) { + _classCallCheck(this, PluginManager); + this.calendar = calendar; + this.settings = new Map(); + this.plugins = new Map(); + this.pendingPaint = new Set(); + } + _createClass(PluginManager, [{ + key: "add", + value: function add(plugins) { + var _this = this; + plugins.forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + PluginClass = _ref2[0], + pluginOptions = _ref2[1]; + var name = extractPluginName(PluginClass, pluginOptions); + var existingPlugin = _this.plugins.get(name); + if (existingPlugin && _this.settings.get(name) && isEqual(_this.settings.get(name).options, pluginOptions)) { + return; + } + _this.settings.set(name, { + options: pluginOptions, + dirty: true + }); + if (!_this.plugins.has(name)) { + _this.plugins.set(name, createPlugin(PluginClass, _this.calendar)); + } + _this.pendingPaint.add(_this.plugins.get(name)); + }); + } + }, { + key: "setupAll", + value: function setupAll() { + var _this2 = this; + this.plugins.forEach(function (pluginInstance, name) { + var settings = _this2.settings.get(name); + if (typeof settings !== 'undefined') { + if (settings.dirty) { + pluginInstance.setup(settings.options); + settings.dirty = false; + _this2.settings.set(name, settings); + } + } + }); + } + }, { + key: "paintAll", + value: function paintAll() { + return Array.from(this.pendingPaint.values()).map(function (p) { + return p.paint(); + }); + } + }, { + key: "destroyAll", + value: function destroyAll() { + return this.allPlugins().map(function (p) { + return p.destroy(); + }); + } + }, { + key: "getFromPosition", + value: function getFromPosition(position) { + return this.allPlugins().filter(function (plugin) { + var _a; + // eslint-disable-next-line implicit-arrow-linebreak + return ((_a = plugin.options) === null || _a === void 0 ? void 0 : _a.position) === position; + }); + } + }, { + key: "getHeightFromPosition", + value: function getHeightFromPosition(position) { + return this.getFromPosition(position).map(function (d) { + return d.options.dimensions.height; + }).reduce(function (a, b) { + return a + b; + }, 0); + } + }, { + key: "getWidthFromPosition", + value: function getWidthFromPosition(position) { + return this.getFromPosition(position).map(function (d) { + return d.options.dimensions.width; + }).reduce(function (a, b) { + return a + b; + }, 0); + } + }, { + key: "allPlugins", + value: function allPlugins() { + return Array.from(this.plugins.values()); + } + }]); + return PluginManager; + }(); + + var VERSION = '4.2.4'; + + var minuteTemplate = function minuteTemplate(DateHelper) { + var COLUMNS_COUNT = 10; + var ROWS_COUNT = 6; + var ALLOWED_DOMAIN_TYPE = ['day', 'hour']; + return { + name: 'minute', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return COLUMNS_COUNT; + }, + columnsCount: function columnsCount() { + return ROWS_COUNT; + }, + mapping: function mapping(startTimestamp, endTimestamp) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + DateHelper.intervals('minute', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts, index) { + return { + t: ts, + x: Math.floor(index / COLUMNS_COUNT), + y: index % COLUMNS_COUNT + }; + }) + ); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('minute').valueOf(); + } + }; + }; + + var hourTemplate = function hourTemplate(DateHelper, _ref) { + var domain = _ref.domain; + var TOTAL_ITEMS = 24; + var ROWS_COUNT = 6; + var ALLOWED_DOMAIN_TYPE = ['month', 'week', 'day']; + return { + name: 'hour', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return ROWS_COUNT; + }, + columnsCount: function columnsCount(ts) { + switch (domain.type) { + case 'week': + return TOTAL_ITEMS / ROWS_COUNT * 7; + case 'month': + return TOTAL_ITEMS / ROWS_COUNT * (domain.dynamicDimension ? DateHelper.date(ts).daysInMonth() : 31); + case 'day': + default: + return TOTAL_ITEMS / ROWS_COUNT; + } + }, + mapping: function mapping(startTimestamp, endTimestamp) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + DateHelper.intervals('hour', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts) { + var date = DateHelper.date(ts); + var hour = date.hour(); + var monthDate = date.date(); + var baseX = Math.floor(hour / ROWS_COUNT); + var columnOffset = TOTAL_ITEMS / ROWS_COUNT; + if (domain.type === 'month') { + baseX += (monthDate - 1) * columnOffset; + } + if (domain.type === 'week') { + baseX += +date.format('d') * columnOffset; + } + return { + t: ts, + x: baseX, + y: Math.floor(hour % ROWS_COUNT) + }; + }) + ); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('hour').valueOf(); + } + }; + }; + + var dayTemplate$2 = function dayTemplate(DateHelper, _ref) { + var domain = _ref.domain, + verticalOrientation = _ref.verticalOrientation; + var ROWS_COUNT = 7; + var ALLOWED_DOMAIN_TYPE = ['year', 'month', 'week']; + return { + name: 'day', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return domain.type === 'week' ? 1 : ROWS_COUNT; + }, + columnsCount: function columnsCount(ts) { + switch (domain.type) { + case 'month': + return Math.ceil(domain.dynamicDimension && !verticalOrientation ? DateHelper.getMonthWeekNumber(DateHelper.date(ts).endOf('month')) : 6); + case 'year': + return Math.ceil(domain.dynamicDimension ? DateHelper.date(ts).endOf('year').dayOfYear() / ROWS_COUNT : 54); + case 'week': + default: + return ROWS_COUNT; + } + }, + mapping: function mapping(startTimestamp, endTimestamp) { + var weekNumber = 0; + var x = -1; + return DateHelper.intervals('day', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts) { + var date = DateHelper.date(ts); + switch (domain.type) { + case 'month': + x = DateHelper.getMonthWeekNumber(ts) - 1; + break; + case 'year': + if (weekNumber !== date.week()) { + weekNumber = date.week(); + x += 1; + } + break; + case 'week': + x = date.weekday(); + break; + } + return { + t: ts, + x: x, + y: domain.type === 'week' ? 0 : date.weekday() + }; + }); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('day').valueOf(); + } + }; + }; + + var dayTemplate$1 = function dayTemplate(DateHelper, _ref) { + var domain = _ref.domain, + verticalOrientation = _ref.verticalOrientation; + var COLUMNS_COUNT = 7; + var ALLOWED_DOMAIN_TYPE = ['year', 'month', 'week']; + return { + name: 'xDay', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount(ts) { + switch (domain.type) { + case 'month': + return Math.ceil(domain.dynamicDimension && !verticalOrientation ? DateHelper.getMonthWeekNumber(DateHelper.date(ts).endOf('month')) : 6); + case 'year': + return Math.ceil(domain.dynamicDimension ? DateHelper.date(ts).endOf('year').dayOfYear() / COLUMNS_COUNT : 54); + case 'week': + default: + return COLUMNS_COUNT; + } + }, + columnsCount: function columnsCount() { + if (domain.type === 'week') { + return 1; + } + return COLUMNS_COUNT; + }, + mapping: function mapping(startTimestamp, endTimestamp) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + DateHelper.intervals('day', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts) { + var date = DateHelper.date(ts); + var endWeekNumber = date.endOf('year').week(); + var x = 0; + switch (domain.type) { + case 'month': + x = DateHelper.getMonthWeekNumber(ts) - 1; + break; + case 'year': + if (endWeekNumber === 1 && date.week() === endWeekNumber) { + x = date.subtract(1, 'week').week() + 1; + } + x = date.week() - 1; + break; + case 'week': + x = date.weekday(); + break; + } + return { + t: ts, + y: x, + x: domain.type === 'week' ? 0 : date.weekday() + }; + }) + ); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('day').valueOf(); + } + }; + }; + + var dayTemplate = function dayTemplate(DateHelper) { + var ROWS_COUNT = 7; + var ALLOWED_DOMAIN_TYPE = ['month']; + return { + name: 'ghDay', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return ROWS_COUNT; + }, + columnsCount: function columnsCount(ts) { + return DateHelper.getWeeksCountInMonth(ts); + }, + mapping: function mapping(startTimestamp, endTimestamp) { + var clampStart = DateHelper.getFirstWeekOfMonth(startTimestamp); + var clampEnd = DateHelper.getFirstWeekOfMonth(endTimestamp); + var x = -1; + var pivotDay = clampStart.weekday(); + return DateHelper.intervals('day', clampStart, clampEnd).map(function (ts) { + var weekday = DateHelper.date(ts).weekday(); + if (weekday === pivotDay) { + x += 1; + } + return { + t: ts, + x: x, + y: weekday + }; + }); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('day').valueOf(); + } + }; + }; + + var weekTemplate = function weekTemplate(DateHelper, _ref) { + var domain = _ref.domain; + var ALLOWED_DOMAIN_TYPE = ['year', 'month']; + return { + name: 'week', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return 1; + }, + columnsCount: function columnsCount(ts) { + switch (domain.type) { + case 'year': + return domain.dynamicDimension ? DateHelper.date(ts).endOf('year').isoWeeksInYear() : 53; + case 'month': + return domain.dynamicDimension ? DateHelper.getWeeksCountInMonth(ts) : 5; + default: + return 1; + } + }, + mapping: function mapping(startTimestamp, endTimestamp) { + var clampStart = DateHelper.getFirstWeekOfMonth(startTimestamp); + var clampEnd = DateHelper.getFirstWeekOfMonth(endTimestamp); + return DateHelper.intervals('week', clampStart, clampEnd).map(function (ts, i) { + return { + t: ts, + x: i, + y: 0 + }; + }); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('week').valueOf(); + } + }; + }; + + var monthTemplate = function monthTemplate(DateHelper) { + var ALLOWED_DOMAIN_TYPE = ['year']; + return { + name: 'month', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return 1; + }, + columnsCount: function columnsCount() { + return 12; + }, + mapping: function mapping(startTimestamp, endTimestamp) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + DateHelper.intervals('month', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts) { + return { + t: ts, + x: DateHelper.date(ts).month(), + y: 0 + }; + }) + ); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('month').valueOf(); + } + }; + }; + + var yearTemplate = function yearTemplate(DateHelper) { + var ALLOWED_DOMAIN_TYPE = []; + return { + name: 'year', + allowedDomainType: ALLOWED_DOMAIN_TYPE, + rowsCount: function rowsCount() { + return 1; + }, + columnsCount: function columnsCount() { + return 1; + }, + mapping: function mapping(startTimestamp, endTimestamp) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + DateHelper.intervals('year', startTimestamp, DateHelper.date(endTimestamp)).map(function (ts, index) { + return { + t: ts, + x: index, + y: 0 + }; + }) + ); + }, + extractUnit: function extractUnit(ts) { + return DateHelper.date(ts).startOf('year').valueOf(); + } + }; + }; + + var DefaultTemplates = [minuteTemplate, hourTemplate, dayTemplate$2, dayTemplate$1, dayTemplate, weekTemplate, monthTemplate, yearTemplate]; + + var TemplateCollection = /*#__PURE__*/function () { + function TemplateCollection(dateHelper, options) { + _classCallCheck(this, TemplateCollection); + this.settings = new Map(); + this.dateHelper = dateHelper; + this.options = options; + this.initiated = false; + } + _createClass(TemplateCollection, [{ + key: "get", + value: function get(subDomainType) { + return this.settings.get(subDomainType); + } + }, { + key: "has", + value: function has(subDomainType) { + return this.settings.has(subDomainType); + } + }, { + key: "init", + value: function init() { + if (!this.initiated) { + this.initiated = true; + this.add(DefaultTemplates); + } + } + }, { + key: "add", + value: function add(templates) { + var _this = this; + this.init(); + var tplWithParent = []; + castArray(templates).forEach(function (f) { + var template = f(_this.dateHelper, _this.options.options); + _this.settings.set(template.name, template); + if (template.hasOwnProperty('parent')) { + tplWithParent.push(template.name); + } + }); + tplWithParent.forEach(function (name) { + var parentTemplate = _this.settings.get(_this.settings.get(name).parent); + if (!parentTemplate) { + return; + } + _this.settings.set(name, Object.assign(Object.assign({}, parentTemplate), _this.settings.get(name))); + }); + } + }]); + return TemplateCollection; + }(); + + var CalHeatmap = /*#__PURE__*/function () { + function CalHeatmap() { + _classCallCheck(this, CalHeatmap); + // Default options + this.options = new Options(); + // Init the helpers with the default options + this.dateHelper = new DateHelper(); + this.templateCollection = new TemplateCollection(this.dateHelper, this.options); + this.dataFetcher = new DataFetcher(this); + this.navigator = new Navigator(this); + this.populator = new Populator(this); + this.calendarPainter = new CalendarPainter(this); + this.eventEmitter = new EventEmitter(); + this.pluginManager = new PluginManager(this); + } + _createClass(CalHeatmap, [{ + key: "createDomainCollection", + value: function createDomainCollection(startDate, range) { + var excludeEnd = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true; + return new DomainCollection(this.dateHelper, this.options.options.domain.type, startDate, range, excludeEnd); + } + // ========================================================================= + // PUBLIC API + // ========================================================================= + /** + * Setup and paint the calendar with the given options + * + * @param {Object} options The Options object + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "paint", + value: function paint(options, plugins) { + return __awaiter(this, void 0, void 0, /*#__PURE__*/_regeneratorRuntime().mark(function _callee() { + return _regeneratorRuntime().wrap(function _callee$(_context) { + while (1) switch (_context.prev = _context.next) { + case 0: + this.options.init(options); + _context.next = 3; + return this.dateHelper.setup(this.options); + case 3: + this.templateCollection.init(); + _context.prev = 4; + validate(this.templateCollection, this.options.options); + _context.next = 11; + break; + case 8: + _context.prev = 8; + _context.t0 = _context["catch"](4); + return _context.abrupt("return", Promise.reject(_context.t0)); + case 11: + if (plugins) { + this.pluginManager.add(castArray(plugins)); + } + this.calendarPainter.setup(); + // Record all the valid domains + // Each domain value is a timestamp in milliseconds + this.domainCollection = new DomainCollection(this.dateHelper); + this.navigator.loadNewDomains(this.createDomainCollection(this.options.options.date.start, this.options.options.range)); + return _context.abrupt("return", Promise.allSettled([this.calendarPainter.paint(), this.fill()])); + case 16: + case "end": + return _context.stop(); + } + }, _callee, this, [[4, 8]]); + })); + } + /** + * Add a new subDomainTemplate + * + * @since 4.0.0 + * @param {SubDomainTemplate[] | SubDomainTemplate} templates + * A single, or an array of SubDomainTemplate object + * @return void + */ + }, { + key: "addTemplates", + value: function addTemplates(templates) { + this.templateCollection.add(templates); + } + /** + * Shift the calendar by n domains forward + * + * @param {number} n Number of domain intervals to shift forward + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "next", + value: function next() { + var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; + var loadDirection = this.navigator.loadNewDomains(this.createDomainCollection(this.domainCollection.max, n + 1).slice(n), ScrollDirection.SCROLL_FORWARD); + return Promise.allSettled([this.calendarPainter.paint(loadDirection), this.fill()]); + } + /** + * Shift the calendar by n domains backward + * + * @param {number} n Number of domain intervals to shift backward + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "previous", + value: function previous() { + var n = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 1; + var loadDirection = this.navigator.loadNewDomains(this.createDomainCollection(this.domainCollection.min, -n), ScrollDirection.SCROLL_BACKWARD); + return Promise.allSettled([this.calendarPainter.paint(loadDirection), this.fill()]); + } + /** + * Jump directly to a specific date + * + * JumpTo will scroll the calendar until the wanted domain with the specified + * date is visible. Unless you set reset to true, the wanted domain + * will not necessarily be the first domain of the calendar. + * + * @param {Date} date Jump to the domain containing that date + * @param {boolean} reset Whether the wanted domain + * should be the first domain of the calendar + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "jumpTo", + value: function jumpTo(date) { + var reset = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false; + return Promise.allSettled([this.calendarPainter.paint(this.navigator.jumpTo(date, reset)), this.fill()]); + } + /** + * Fill the calendar with the given data + * + * @param {Object|string} dataSource The calendar's datasource, + * same type as `options.data.source` + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "fill", + value: function fill() { + var _this = this; + var dataSource = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : this.options.options.data.source; + var options = this.options.options; + var template = this.templateCollection; + var endDate = this.dateHelper.intervals(options.domain.type, this.domainCollection.max, 2)[1]; + var dataPromise = this.dataFetcher.getDatas(dataSource, this.domainCollection.min, endDate); + return new Promise(function (resolve, reject) { + dataPromise.then(function (data) { + _this.domainCollection.fill(data, options.data, template.get(options.subDomain.type).extractUnit); + _this.populator.populate(); + resolve(null); + }, function (error) { + reject(error); + }); + }); + } + /** + * Listener for all events + * + * @since 4.0.0 + * @param {string} eventName Name of the event to listen to + * @param {function} Callback function to execute on event trigger + * @return void + */ + }, { + key: "on", + value: function on(name, fn) { + this.eventEmitter.on(name, fn); + } + }, { + key: "dimensions", + value: function dimensions() { + return this.calendarPainter.dimensions; + } + /** + * Destroy the calendar + * + * @since 3.3.6 + * @return A Promise, which will fulfill once all the underlying asynchronous + * tasks settle, whether resolved or rejected. + */ + }, { + key: "destroy", + value: function destroy() { + return this.calendarPainter.destroy(); + } + }, { + key: "extendDayjs", + value: function extendDayjs(plugin) { + return this.dateHelper.extend(plugin); + } + }]); + return CalHeatmap; + }(); + CalHeatmap.VERSION = VERSION; + + return CalHeatmap; + +})); diff --git a/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.esm.js b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.esm.js new file mode 100644 index 0000000..d361a90 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.esm.js @@ -0,0 +1 @@ +import{select as t}from"d3-selection";import{hcl as e}from"d3-color";import{ascending as n,timeSecond as r,timeMinute as i,timeHour as o,timeDay as a,timeWeek as u,timeMonth as s,timeYear as c,timeMonday as l,timeTuesday as f,timeWednesday as h,timeThursday as d,timeFriday as p,timeSaturday as v,timeSunday as y,utcSecond as m,utcMinute as g,utcHour as w,utcDay as b,utcWeek as x,utcMonth as O,utcYear as k,utcMonday as S,utcTuesday as j,utcWednesday as _,utcThursday as M,utcFriday as D,utcSaturday as $,utcSunday as E,descending as P,range as L,symbolAsterisk as A,symbolCircle as C,symbolCross as T,symbolDiamond as R,symbolDiamond2 as I,symbolPlus as N,symbolSquare as W,symbolSquare2 as F,symbolStar as z,symbolTimes as H,symbolTriangle as Y,symbolTriangle2 as U,symbolWye as B,schemeAccent as G,schemeCategory10 as V,schemeDark2 as q,schemePaired as K,schemePastel1 as Z,schemePastel2 as J,schemeSet1 as Q,schemeSet2 as X,schemeSet3 as tt,schemeTableau10 as et,quantize as nt,interpolateBrBG as rt,interpolatePRGn as it,interpolatePiYG as ot,interpolatePuOr as at,interpolateRdBu as ut,interpolateRdGy as st,interpolateRdYlBu as ct,interpolateRdYlGn as lt,interpolateSpectral as ft,interpolateBlues as ht,interpolateGreens as dt,interpolateGreys as pt,interpolatePurples as vt,interpolateReds as yt,interpolateOranges as mt,interpolateTurbo as gt,interpolateViridis as wt,interpolateMagma as bt,interpolateInferno as xt,interpolatePlasma as Ot,interpolateCividis as kt,interpolateCubehelixDefault as St,interpolateWarm as jt,interpolateCool as _t,interpolateBuGn as Mt,interpolateBuPu as Dt,interpolateGnBu as $t,interpolateOrRd as Et,interpolatePuBuGn as Pt,interpolatePuBu as Lt,interpolatePuRd as At,interpolateRdPu as Ct,interpolateYlGnBu as Tt,interpolateYlGn as Rt,interpolateYlOrBr as It,interpolateYlOrRd as Nt,interpolateRainbow as Wt,interpolateSinebow as Ft,schemeBrBG as zt,schemePRGn as Ht,schemePiYG as Yt,schemePuOr as Ut,schemeRdBu as Bt,schemeRdGy as Gt,schemeRdYlBu as Vt,schemeRdYlGn as qt,schemeSpectral as Kt,schemeBlues as Zt,schemeGreens as Jt,schemeGreys as Qt,schemeOranges as Xt,schemePurples as te,schemeReds as ee,schemeBuGn as ne,schemeBuPu as re,schemeGnBu as ie,schemeOrRd as oe,schemePuBu as ae,schemePuBuGn as ue,schemePuRd as se,schemeRdPu as ce,schemeYlGn as le,schemeYlGnBu as fe,schemeYlOrBr as he,schemeYlOrRd as de,scaleLinear as pe,scalePow as ve,scaleLog as ye,scaleSymlog as me,scaleQuantile as ge,extent as we,ticks as be,interpolateNumber as xe,reverse as Oe,scaleThreshold as ke,scaleIdentity as Se,max as je,interpolateRgb as _e,interpolateRound as Me,min as De,quantile as $e,median as Ee,interpolateHsl as Pe,interpolateHcl as Le,interpolateLab as Ae,scaleDiverging as Ce,scaleDivergingPow as Te,scaleDivergingLog as Re,scaleDivergingSymlog as Ie,piecewise as Ne,scaleTime as We,scaleUtc as Fe,scaleImplicit as ze,scaleOrdinal as He,scalePoint as Ye,scaleBand as Ue,InternSet as Be,sort as Ge,symbolsStroke as Ve,symbolsFill as qe}from"d3";import{text as Ke,dsv as Ze,csv as Je,json as Qe}from"d3-fetch";function Xe(){Xe=function(){return t};var t={},e=Object.prototype,n=e.hasOwnProperty,r=Object.defineProperty||function(t,e,n){t[e]=n.value},i="function"==typeof Symbol?Symbol:{},o=i.iterator||"@@iterator",a=i.asyncIterator||"@@asyncIterator",u=i.toStringTag||"@@toStringTag";function s(t,e,n){return Object.defineProperty(t,e,{value:n,enumerable:!0,configurable:!0,writable:!0}),t[e]}try{s({},"")}catch(t){s=function(t,e,n){return t[e]=n}}function c(t,e,n,i){var o=e&&e.prototype instanceof h?e:h,a=Object.create(o.prototype),u=new j(i||[]);return r(a,"_invoke",{value:x(t,n,u)}),a}function l(t,e,n){try{return{type:"normal",arg:t.call(e,n)}}catch(t){return{type:"throw",arg:t}}}t.wrap=c;var f={};function h(){}function d(){}function p(){}var v={};s(v,o,(function(){return this}));var y=Object.getPrototypeOf,m=y&&y(y(_([])));m&&m!==e&&n.call(m,o)&&(v=m);var g=p.prototype=h.prototype=Object.create(v);function w(t){["next","throw","return"].forEach((function(e){s(t,e,(function(t){return this._invoke(e,t)}))}))}function b(t,e){function i(r,o,a,u){var s=l(t[r],t,o);if("throw"!==s.type){var c=s.arg,f=c.value;return f&&"object"==typeof f&&n.call(f,"__await")?e.resolve(f.__await).then((function(t){i("next",t,a,u)}),(function(t){i("throw",t,a,u)})):e.resolve(f).then((function(t){c.value=t,a(c)}),(function(t){return i("throw",t,a,u)}))}u(s.arg)}var o;r(this,"_invoke",{value:function(t,n){function r(){return new e((function(e,r){i(t,n,e,r)}))}return o=o?o.then(r,r):r()}})}function x(t,e,n){var r="suspendedStart";return function(i,o){if("executing"===r)throw new Error("Generator is already running");if("completed"===r){if("throw"===i)throw o;return M()}for(n.method=i,n.arg=o;;){var a=n.delegate;if(a){var u=O(a,n);if(u){if(u===f)continue;return u}}if("next"===n.method)n.sent=n._sent=n.arg;else if("throw"===n.method){if("suspendedStart"===r)throw r="completed",n.arg;n.dispatchException(n.arg)}else"return"===n.method&&n.abrupt("return",n.arg);r="executing";var s=l(t,e,n);if("normal"===s.type){if(r=n.done?"completed":"suspendedYield",s.arg===f)continue;return{value:s.arg,done:n.done}}"throw"===s.type&&(r="completed",n.method="throw",n.arg=s.arg)}}}function O(t,e){var n=e.method,r=t.iterator[n];if(void 0===r)return e.delegate=null,"throw"===n&&t.iterator.return&&(e.method="return",e.arg=void 0,O(t,e),"throw"===e.method)||"return"!==n&&(e.method="throw",e.arg=new TypeError("The iterator does not provide a '"+n+"' method")),f;var i=l(r,t.iterator,e.arg);if("throw"===i.type)return e.method="throw",e.arg=i.arg,e.delegate=null,f;var o=i.arg;return o?o.done?(e[t.resultName]=o.value,e.next=t.nextLoc,"return"!==e.method&&(e.method="next",e.arg=void 0),e.delegate=null,f):o:(e.method="throw",e.arg=new TypeError("iterator result is not an object"),e.delegate=null,f)}function k(t){var e={tryLoc:t[0]};1 in t&&(e.catchLoc=t[1]),2 in t&&(e.finallyLoc=t[2],e.afterLoc=t[3]),this.tryEntries.push(e)}function S(t){var e=t.completion||{};e.type="normal",delete e.arg,t.completion=e}function j(t){this.tryEntries=[{tryLoc:"root"}],t.forEach(k,this),this.reset(!0)}function _(t){if(t){var e=t[o];if(e)return e.call(t);if("function"==typeof t.next)return t;if(!isNaN(t.length)){var r=-1,i=function e(){for(;++r=0;--i){var o=this.tryEntries[i],a=o.completion;if("root"===o.tryLoc)return r("end");if(o.tryLoc<=this.prev){var u=n.call(o,"catchLoc"),s=n.call(o,"finallyLoc");if(u&&s){if(this.prev=0;--r){var i=this.tryEntries[r];if(i.tryLoc<=this.prev&&n.call(i,"finallyLoc")&&this.prev=0;--e){var n=this.tryEntries[e];if(n.finallyLoc===t)return this.complete(n.completion,n.afterLoc),S(n),f}},catch:function(t){for(var e=this.tryEntries.length-1;e>=0;--e){var n=this.tryEntries[e];if(n.tryLoc===t){var r=n.completion;if("throw"===r.type){var i=r.arg;S(n)}return i}}throw new Error("illegal catch attempt")},delegateYield:function(t,e,n){return this.delegate={iterator:_(t),resultName:e,nextLoc:n},"next"===this.method&&(this.arg=void 0),f}},t}function tn(t){return tn="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},tn(t)}function en(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function nn(t,e){for(var n=0;nt.length)&&(e=t.length);for(var n=0,r=new Array(e);n0&&On[0]<4?1:+(On[0]+On[1])),!kn&&Kn&&(!(On=Kn.match(/Edge\/(\d+)/))||On[1]>=74)&&(On=Kn.match(/Chrome\/(\d+)/))&&(kn=+On[1]);var tr=kn,er=tr,nr=jn,rr=dn.String,ir=!!Object.getOwnPropertySymbols&&!nr((function(){var t=Symbol("symbol detection");return!rr(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&er&&er<41})),or=ir&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,ar=Sn,ur=zn,sr=Gn,cr=ir,lr=or,fr=dn.Symbol,hr=ar("wks"),dr=lr?fr.for||fr:fr&&fr.withoutSetter||sr,pr=function(t){return ur(hr,t)||(hr[t]=cr&&ur(fr,t)?fr[t]:dr("Symbol."+t)),hr[t]},vr={};vr[pr("toStringTag")]="z";var yr="[object z]"===String(vr),mr="object"==typeof document&&document.all,gr={all:mr,IS_HTMLDDA:void 0===mr&&void 0!==mr},wr=gr.all,br=gr.IS_HTMLDDA?function(t){return"function"==typeof t||t===wr}:function(t){return"function"==typeof t},xr={},Or=!jn((function(){return 7!==Object.defineProperty({},1,{get:function(){return 7}})[1]})),kr=br,Sr=gr.all,jr=gr.IS_HTMLDDA?function(t){return"object"==typeof t?null!==t:kr(t)||t===Sr}:function(t){return"object"==typeof t?null!==t:kr(t)},_r=jr,Mr=dn.document,Dr=_r(Mr)&&_r(Mr.createElement),$r=function(t){return Dr?Mr.createElement(t):{}},Er=$r,Pr=!Or&&!jn((function(){return 7!==Object.defineProperty(Er("div"),"a",{get:function(){return 7}}).a})),Lr=Or&&jn((function(){return 42!==Object.defineProperty((function(){}),"prototype",{value:42,writable:!1}).prototype})),Ar=jr,Cr=String,Tr=TypeError,Rr=function(t){if(Ar(t))return t;throw new Tr(Cr(t)+" is not an object")},Ir=_n,Nr=Function.prototype.call,Wr=Ir?Nr.bind(Nr):function(){return Nr.apply(Nr,arguments)},Fr=dn,zr=br,Hr=function(t,e){return arguments.length<2?(n=Fr[t],zr(n)?n:void 0):Fr[t]&&Fr[t][e];var n},Yr=Pn({}.isPrototypeOf),Ur=Hr,Br=br,Gr=Yr,Vr=Object,qr=or?function(t){return"symbol"==typeof t}:function(t){var e=Ur("Symbol");return Br(e)&&Gr(e.prototype,Vr(t))},Kr=String,Zr=function(t){try{return Kr(t)}catch(t){return"Object"}},Jr=br,Qr=Zr,Xr=TypeError,ti=function(t){if(Jr(t))return t;throw new Xr(Qr(t)+" is not a function")},ei=ti,ni=Ln,ri=function(t,e){var n=t[e];return ni(n)?void 0:ei(n)},ii=Wr,oi=br,ai=jr,ui=TypeError,si=Wr,ci=jr,li=qr,fi=ri,hi=function(t,e){var n,r;if("string"===e&&oi(n=t.toString)&&!ai(r=ii(n,t)))return r;if(oi(n=t.valueOf)&&!ai(r=ii(n,t)))return r;if("string"!==e&&oi(n=t.toString)&&!ai(r=ii(n,t)))return r;throw new ui("Can't convert object to primitive value")},di=TypeError,pi=pr("toPrimitive"),vi=function(t,e){if(!ci(t)||li(t))return t;var n,r=fi(t,pi);if(r){if(void 0===e&&(e="default"),n=si(r,t,e),!ci(n)||li(n))return n;throw new di("Can't convert object to primitive value")}return void 0===e&&(e="number"),hi(t,e)},yi=qr,mi=function(t){var e=vi(t,"string");return yi(e)?e:e+""},gi=Or,wi=Pr,bi=Lr,xi=Rr,Oi=mi,ki=TypeError,Si=Object.defineProperty,ji=Object.getOwnPropertyDescriptor,_i="enumerable",Mi="configurable",Di="writable";xr.f=gi?bi?function(t,e,n){if(xi(t),e=Oi(e),xi(n),"function"==typeof t&&"prototype"===e&&"value"in n&&Di in n&&!n[Di]){var r=ji(t,e);r&&r[Di]&&(t[e]=n.value,n={configurable:Mi in n?n[Mi]:r[Mi],enumerable:_i in n?n[_i]:r[_i],writable:!1})}return Si(t,e,n)}:Si:function(t,e,n){if(xi(t),e=Oi(e),xi(n),wi)try{return Si(t,e,n)}catch(t){}if("get"in n||"set"in n)throw new ki("Accessors not supported");return"value"in n&&(t[e]=n.value),t};var $i={exports:{}},Ei=Or,Pi=zn,Li=Function.prototype,Ai=Ei&&Object.getOwnPropertyDescriptor,Ci=Pi(Li,"name"),Ti={EXISTS:Ci,PROPER:Ci&&"something"===function(){}.name,CONFIGURABLE:Ci&&(!Ei||Ei&&Ai(Li,"name").configurable)},Ri=br,Ii=bn,Ni=Pn(Function.toString);Ri(Ii.inspectSource)||(Ii.inspectSource=function(t){return Ni(t)});var Wi,Fi,zi,Hi=Ii.inspectSource,Yi=br,Ui=dn.WeakMap,Bi=Yi(Ui)&&/native code/.test(String(Ui)),Gi=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}},Vi=xr,qi=Gi,Ki=Or?function(t,e,n){return Vi.f(t,e,qi(1,n))}:function(t,e,n){return t[e]=n,t},Zi=Gn,Ji=Sn("keys"),Qi=function(t){return Ji[t]||(Ji[t]=Zi(t))},Xi={},to=Bi,eo=dn,no=jr,ro=Ki,io=zn,oo=bn,ao=Qi,uo=Xi,so="Object already initialized",co=eo.TypeError,lo=eo.WeakMap;if(to||oo.state){var fo=oo.state||(oo.state=new lo);fo.get=fo.get,fo.has=fo.has,fo.set=fo.set,Wi=function(t,e){if(fo.has(t))throw new co(so);return e.facade=t,fo.set(t,e),e},Fi=function(t){return fo.get(t)||{}},zi=function(t){return fo.has(t)}}else{var ho=ao("state");uo[ho]=!0,Wi=function(t,e){if(io(t,ho))throw new co(so);return e.facade=t,ro(t,ho,e),e},Fi=function(t){return io(t,ho)?t[ho]:{}},zi=function(t){return io(t,ho)}}var po={set:Wi,get:Fi,has:zi,enforce:function(t){return zi(t)?Fi(t):Wi(t,{})},getterFor:function(t){return function(e){var n;if(!no(e)||(n=Fi(e)).type!==t)throw new co("Incompatible receiver, "+t+" required");return n}}},vo=Pn,yo=jn,mo=br,go=zn,wo=Or,bo=Ti.CONFIGURABLE,xo=Hi,Oo=po.enforce,ko=po.get,So=String,jo=Object.defineProperty,_o=vo("".slice),Mo=vo("".replace),Do=vo([].join),$o=wo&&!yo((function(){return 8!==jo((function(){}),"length",{value:8}).length})),Eo=String(String).split("String"),Po=$i.exports=function(t,e,n){"Symbol("===_o(So(e),0,7)&&(e="["+Mo(So(e),/^Symbol\(([^)]*)\)/,"$1")+"]"),n&&n.getter&&(e="get "+e),n&&n.setter&&(e="set "+e),(!go(t,"name")||bo&&t.name!==e)&&(wo?jo(t,"name",{value:e,configurable:!0}):t.name=e),$o&&n&&go(n,"arity")&&t.length!==n.arity&&jo(t,"length",{value:n.arity});try{n&&go(n,"constructor")&&n.constructor?wo&&jo(t,"prototype",{writable:!1}):t.prototype&&(t.prototype=void 0)}catch(t){}var r=Oo(t);return go(r,"source")||(r.source=Do(Eo,"string"==typeof e?e:"")),t};Function.prototype.toString=Po((function(){return mo(this)&&ko(this).source||xo(this)}),"toString");var Lo=$i.exports,Ao=br,Co=xr,To=Lo,Ro=mn,Io=function(t,e,n,r){r||(r={});var i=r.enumerable,o=void 0!==r.name?r.name:e;if(Ao(n)&&To(n,o,r),r.global)i?t[e]=n:Ro(e,n);else{try{r.unsafe?t[e]&&(i=!0):delete t[e]}catch(t){}i?t[e]=n:Co.f(t,e,{value:n,enumerable:!1,configurable:!r.nonConfigurable,writable:!r.nonWritable})}return t},No=Pn,Wo=No({}.toString),Fo=No("".slice),zo=function(t){return Fo(Wo(t),8,-1)},Ho=yr,Yo=br,Uo=zo,Bo=pr("toStringTag"),Go=Object,Vo="Arguments"===Uo(function(){return arguments}()),qo=Ho?Uo:function(t){var e,n,r;return void 0===t?"Undefined":null===t?"Null":"string"==typeof(n=function(t,e){try{return t[e]}catch(t){}}(e=Go(t),Bo))?n:Vo?Uo(e):"Object"===(r=Uo(e))&&Yo(e.callee)?"Arguments":r},Ko=qo,Zo=yr?{}.toString:function(){return"[object "+Ko(this)+"]"};yr||Io(Object.prototype,"toString",Zo,{unsafe:!0});var Jo={},Qo={},Xo={}.propertyIsEnumerable,ta=Object.getOwnPropertyDescriptor,ea=ta&&!Xo.call({1:2},1);Qo.f=ea?function(t){var e=ta(this,t);return!!e&&e.enumerable}:Xo;var na=jn,ra=zo,ia=Object,oa=Pn("".split),aa=na((function(){return!ia("z").propertyIsEnumerable(0)}))?function(t){return"String"===ra(t)?oa(t,""):ia(t)}:ia,ua=aa,sa=Tn,ca=function(t){return ua(sa(t))},la=Or,fa=Wr,ha=Qo,da=Gi,pa=ca,va=mi,ya=zn,ma=Pr,ga=Object.getOwnPropertyDescriptor;Jo.f=la?ga:function(t,e){if(t=pa(t),e=va(e),ma)try{return ga(t,e)}catch(t){}if(ya(t,e))return da(!fa(ha.f,t,e),t[e])};var wa={},ba=Math.ceil,xa=Math.floor,Oa=Math.trunc||function(t){var e=+t;return(e>0?xa:ba)(e)},ka=function(t){var e=+t;return e!=e||0===e?0:Oa(e)},Sa=ka,ja=Math.max,_a=Math.min,Ma=function(t,e){var n=Sa(t);return n<0?ja(n+e,0):_a(n,e)},Da=ka,$a=Math.min,Ea=function(t){return t>0?$a(Da(t),9007199254740991):0},Pa=Ea,La=function(t){return Pa(t.length)},Aa=ca,Ca=Ma,Ta=La,Ra=function(t){return function(e,n,r){var i,o=Aa(e),a=Ta(o),u=Ca(r,a);if(t&&n!=n){for(;a>u;)if((i=o[u++])!=i)return!0}else for(;a>u;u++)if((t||u in o)&&o[u]===n)return t||u||0;return!t&&-1}},Ia={includes:Ra(!0),indexOf:Ra(!1)},Na=zn,Wa=ca,Fa=Ia.indexOf,za=Xi,Ha=Pn([].push),Ya=function(t,e){var n,r=Wa(t),i=0,o=[];for(n in r)!Na(za,n)&&Na(r,n)&&Ha(o,n);for(;e.length>i;)Na(r,n=e[i++])&&(~Fa(o,n)||Ha(o,n));return o},Ua=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],Ba=Ya,Ga=Ua.concat("length","prototype");wa.f=Object.getOwnPropertyNames||function(t){return Ba(t,Ga)};var Va={};Va.f=Object.getOwnPropertySymbols;var qa=Hr,Ka=wa,Za=Va,Ja=Rr,Qa=Pn([].concat),Xa=qa("Reflect","ownKeys")||function(t){var e=Ka.f(Ja(t)),n=Za.f;return n?Qa(e,n(t)):e},tu=zn,eu=Xa,nu=Jo,ru=xr,iu=jn,ou=br,au=/#|\.prototype\./,uu=function(t,e){var n=cu[su(t)];return n===fu||n!==lu&&(ou(e)?iu(e):!!e)},su=uu.normalize=function(t){return String(t).replace(au,".").toLowerCase()},cu=uu.data={},lu=uu.NATIVE="N",fu=uu.POLYFILL="P",hu=uu,du=dn,pu=Jo.f,vu=Ki,yu=Io,mu=mn,gu=function(t,e,n){for(var r=eu(e),i=ru.f,o=nu.f,a=0;ao;o++)if((u=m(t[o]))&&_f(Lf,u))return u;return new Pf(!1)}r=Mf(t,i)}for(s=h?t.next:r.next;!(c=xf(s,r)).done;){try{u=m(c.value)}catch(t){$f(r,"throw",t)}if("object"==typeof u&&u&&_f(Lf,u))return u}return new Pf(!1)},Cf=pr("iterator"),Tf=!1;try{var Rf=0,If={next:function(){return{done:!!Rf++}},return:function(){Tf=!0}};If[Cf]=function(){return this},Array.from(If,(function(){throw 2}))}catch(t){}var Nf=function(t,e){try{if(!e&&!Tf)return!1}catch(t){return!1}var n=!1;try{var r={};r[Cf]=function(){return{next:function(){return{done:n=!0}}}},t(r)}catch(t){}return n},Wf=Cc,Ff=Zc.CONSTRUCTOR||!Nf((function(t){Wf.all(t).then(void 0,(function(){}))})),zf=Wr,Hf=ti,Yf=Jc,Uf=Ac,Bf=Af;bu({target:"Promise",stat:!0,forced:Ff},{all:function(t){var e=this,n=Yf.f(e),r=n.resolve,i=n.reject,o=Uf((function(){var n=Hf(e.resolve),o=[],a=0,u=1;Bf(t,(function(t){var s=a++,c=!1;u++,zf(n,e,t).then((function(t){c||(c=!0,o[s]=t,--u||r(o))}),i)})),--u||r(o)}));return o.error&&i(o.value),n.promise}});var Gf=bu,Vf=Zc.CONSTRUCTOR,qf=Cc,Kf=Hr,Zf=br,Jf=Io,Qf=qf&&qf.prototype;if(Gf({target:"Promise",proto:!0,forced:Vf,real:!0},{catch:function(t){return this.then(void 0,t)}}),Zf(qf)){var Xf=Kf("Promise").prototype.catch;Qf.catch!==Xf&&Jf(Qf,"catch",Xf,{unsafe:!0})}var th=Wr,eh=ti,nh=Jc,rh=Ac,ih=Af;bu({target:"Promise",stat:!0,forced:Ff},{race:function(t){var e=this,n=nh.f(e),r=n.reject,i=rh((function(){var i=eh(e.resolve);ih(t,(function(t){th(i,e,t).then(n.resolve,r)}))}));return i.error&&r(i.value),n.promise}});var oh=Wr,ah=Jc;bu({target:"Promise",stat:!0,forced:Zc.CONSTRUCTOR},{reject:function(t){var e=ah.f(this);return oh(e.reject,void 0,t),e.promise}});var uh=Rr,sh=jr,ch=Jc,lh=bu,fh=Zc.CONSTRUCTOR,hh=function(t,e){if(uh(t),sh(e)&&e.constructor===t)return e;var n=ch.f(t);return(0,n.resolve)(e),n.promise};Hr("Promise"),lh({target:"Promise",stat:!0,forced:fh},{resolve:function(t){return hh(this,t)}});var dh={},ph=Ya,vh=Ua,yh=Object.keys||function(t){return ph(t,vh)},mh=Or,gh=Lr,wh=xr,bh=Rr,xh=ca,Oh=yh;dh.f=mh&&!gh?Object.defineProperties:function(t,e){bh(t);for(var n,r=xh(e),i=Oh(e),o=i.length,a=0;o>a;)wh.f(t,n=i[a++],r[n]);return t};var kh,Sh=Rr,jh=dh,_h=Ua,Mh=Xi,Dh=$s,$h=$r,Eh="prototype",Ph="script",Lh=Qi("IE_PROTO"),Ah=function(){},Ch=function(t){return"<"+Ph+">"+t+""},Th=function(t){t.write(Ch("")),t.close();var e=t.parentWindow.Object;return t=null,e},Rh=function(){try{kh=new ActiveXObject("htmlfile")}catch(t){}var t,e,n;Rh="undefined"!=typeof document?document.domain&&kh?Th(kh):(e=$h("iframe"),n="java"+Ph+":",e.style.display="none",Dh.appendChild(e),e.src=String(n),(t=e.contentWindow.document).open(),t.write(Ch("document.F=Object")),t.close(),t.F):Th(kh);for(var r=_h.length;r--;)delete Rh[Eh][_h[r]];return Rh()};Mh[Lh]=!0;var Ih=Object.create||function(t,e){var n;return null!==t?(Ah[Eh]=Sh(t),n=new Ah,Ah[Eh]=null,n[Lh]=t):n=Rh(),void 0===e?n:jh.f(n,e)},Nh=pr,Wh=Ih,Fh=xr.f,zh=Nh("unscopables"),Hh=Array.prototype;void 0===Hh[zh]&&Fh(Hh,zh,{configurable:!0,value:Wh(null)});var Yh,Uh,Bh,Gh=function(t){Hh[zh][t]=!0},Vh=!jn((function(){function t(){}return t.prototype.constructor=null,Object.getPrototypeOf(new t)!==t.prototype})),qh=zn,Kh=br,Zh=Nn,Jh=Vh,Qh=Qi("IE_PROTO"),Xh=Object,td=Xh.prototype,ed=Jh?Xh.getPrototypeOf:function(t){var e=Zh(t);if(qh(e,Qh))return e[Qh];var n=e.constructor;return Kh(n)&&e instanceof n?n.prototype:e instanceof Xh?td:null},nd=jn,rd=br,id=jr,od=ed,ad=Io,ud=pr("iterator"),sd=!1;[].keys&&("next"in(Bh=[].keys())?(Uh=od(od(Bh)))!==Object.prototype&&(Yh=Uh):sd=!0);var cd=!id(Yh)||nd((function(){var t={};return Yh[ud].call(t)!==t}));cd&&(Yh={}),rd(Yh[ud])||ad(Yh,ud,(function(){return this}));var ld={IteratorPrototype:Yh,BUGGY_SAFARI_ITERATORS:sd},fd=ld.IteratorPrototype,hd=Ih,dd=Gi,pd=Cu,vd=Jl,yd=function(){return this},md=bu,gd=Wr,wd=br,bd=function(t,e,n,r){var i=e+" Iterator";return t.prototype=hd(fd,{next:dd(+!r,n)}),pd(t,i,!1),vd[i]=yd,t},xd=ed,Od=Eu,kd=Cu,Sd=Ki,jd=Io,_d=Jl,Md=Ti.PROPER,Dd=Ti.CONFIGURABLE,$d=ld.IteratorPrototype,Ed=ld.BUGGY_SAFARI_ITERATORS,Pd=pr("iterator"),Ld="keys",Ad="values",Cd="entries",Td=function(){return this},Rd=function(t,e,n,r,i,o,a){bd(n,e,r);var u,s,c,l=function(t){if(t===i&&v)return v;if(!Ed&&t&&t in d)return d[t];switch(t){case Ld:case Ad:case Cd:return function(){return new n(this,t)}}return function(){return new n(this)}},f=e+" Iterator",h=!1,d=t.prototype,p=d[Pd]||d["@@iterator"]||i&&d[i],v=!Ed&&p||l(i),y="Array"===e&&d.entries||p;if(y&&(u=xd(y.call(new t)))!==Object.prototype&&u.next&&(xd(u)!==$d&&(Od?Od(u,$d):wd(u[Pd])||jd(u,Pd,Td)),kd(u,f,!0)),Md&&i===Ad&&p&&p.name!==Ad&&(Dd?Sd(d,"name",Ad):(h=!0,v=function(){return gd(p,this)})),i)if(s={values:l(Ad),keys:o?v:l(Ld),entries:l(Cd)},a)for(c in s)(Ed||h||!(c in d))&&jd(d,c,s[c]);else md({target:e,proto:!0,forced:Ed||h},s);return d[Pd]!==v&&jd(d,Pd,v,{name:i}),_d[e]=v,s},Id=function(t,e){return{value:t,done:e}},Nd=ca,Wd=Gh,Fd=Jl,zd=po,Hd=xr.f,Yd=Rd,Ud=Id,Bd=Or,Gd="Array Iterator",Vd=zd.set,qd=zd.getterFor(Gd),Kd=Yd(Array,"Array",(function(t,e){Vd(this,{type:Gd,target:Nd(t),index:0,kind:e})}),(function(){var t=qd(this),e=t.target,n=t.index++;if(!e||n>=e.length)return t.target=void 0,Ud(void 0,!0);switch(t.kind){case"keys":return Ud(n,!1);case"values":return Ud(e[n],!1)}return Ud([n,e[n]],!1)}),"values"),Zd=Fd.Arguments=Fd.Array;if(Wd("keys"),Wd("values"),Wd("entries"),Bd&&"values"!==Zd.name)try{Hd(Zd,"name",{value:"values"})}catch(t){}var Jd=Wr,Qd=ti,Xd=Jc,tp=Ac,ep=Af;bu({target:"Promise",stat:!0,forced:Ff},{allSettled:function(t){var e=this,n=Xd.f(e),r=n.resolve,i=n.reject,o=tp((function(){var n=Qd(e.resolve),i=[],o=0,a=1;ep(t,(function(t){var u=o++,s=!1;a++,Jd(n,e,t).then((function(t){s||(s=!0,i[u]={status:"fulfilled",value:t},--a||r(i))}),(function(t){s||(s=!0,i[u]={status:"rejected",reason:t},--a||r(i))}))})),--a||r(i)}));return o.error&&i(o.value),n.promise}});var np=qo,rp=String,ip=function(t){if("Symbol"===np(t))throw new TypeError("Cannot convert a Symbol value to a string");return rp(t)},op=Pn,ap=ka,up=ip,sp=Tn,cp=op("".charAt),lp=op("".charCodeAt),fp=op("".slice),hp=function(t){return function(e,n){var r,i,o=up(sp(e)),a=ap(n),u=o.length;return a<0||a>=u?t?"":void 0:(r=lp(o,a))<55296||r>56319||a+1===u||(i=lp(o,a+1))<56320||i>57343?t?cp(o,a):r:t?fp(o,a,a+2):i-56320+(r-55296<<10)+65536}},dp={codeAt:hp(!1),charAt:hp(!0)},pp=dp.charAt,vp=ip,yp=po,mp=Rd,gp=Id,wp="String Iterator",bp=yp.set,xp=yp.getterFor(wp);mp(String,"String",(function(t){bp(this,{type:wp,string:vp(t),index:0})}),(function(){var t,e=xp(this),n=e.string,r=e.index;return r>=n.length?gp(void 0,!0):(t=pp(n,r),e.index+=t.length,gp(t,!1))}));var Op={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0},kp=$r("span").classList,Sp=kp&&kp.constructor&&kp.constructor.prototype,jp=Sp===Object.prototype?void 0:Sp,_p=dn,Mp=Op,Dp=jp,$p=Kd,Ep=Ki,Pp=Cu,Lp=pr("iterator"),Ap=$p.values,Cp=function(t,e){if(t){if(t[Lp]!==Ap)try{Ep(t,Lp,Ap)}catch(e){t[Lp]=Ap}if(Pp(t,e,!0),Mp[e])for(var n in $p)if(t[n]!==$p[n])try{Ep(t,n,$p[n])}catch(e){t[n]=$p[n]}}};for(var Tp in Mp)Cp(_p[Tp]&&_p[Tp].prototype,Tp);Cp(Dp,"DOMTokenList");var Rp=Nn,Ip=Ma,Np=La,Wp=function(t){for(var e=Rp(this),n=Np(e),r=arguments.length,i=Ip(r>1?arguments[1]:void 0,n),o=r>2?arguments[2]:void 0,a=void 0===o?n:Ip(o,n);a>i;)e[i++]=t;return e},Fp=Gh;bu({target:"Array",proto:!0},{fill:Wp}),Fp("fill");var zp=zo,Hp=Array.isArray||function(t){return"Array"===zp(t)},Yp=mi,Up=xr,Bp=Gi,Gp=function(t,e,n){var r=Yp(e);r in t?Up.f(t,r,Bp(0,n)):t[r]=n},Vp=jn,qp=tr,Kp=pr("species"),Zp=function(t){return qp>=51||!Vp((function(){var e=[];return(e.constructor={})[Kp]=function(){return{foo:1}},1!==e[t](Boolean).foo}))},Jp=bu,Qp=Hp,Xp=cs,tv=jr,ev=Ma,nv=La,rv=ca,iv=Gp,ov=pr,av=Es,uv=Zp("slice"),sv=ov("species"),cv=Array,lv=Math.max;function fv(t,e,n,r){return new(n||(n=Promise))((function(i,o){function a(t){try{s(r.next(t))}catch(t){o(t)}}function u(t){try{s(r.throw(t))}catch(t){o(t)}}function s(t){var e;t.done?i(t.value):(e=t.value,e instanceof n?e:new n((function(t){t(e)}))).then(a,u)}s((r=r.apply(t,e||[])).next())}))}function hv(t,e,n,r){if("a"===n&&!r)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof e?t!==e||!r:!e.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===n?r:"a"===n?r.call(t):r?r.value:e.get(t)}Jp({target:"Array",proto:!0,forced:!uv},{slice:function(t,e){var n,r,i,o=rv(this),a=nv(o),u=ev(t,a),s=ev(void 0===e?a:e,a);if(Qp(o)&&(n=o.constructor,(Xp(n)&&(n===cv||Qp(n.prototype))||tv(n)&&null===(n=n[sv]))&&(n=void 0),n===cv||void 0===n))return av(o,u,s);for(r=new(void 0===n?cv:n)(lv(s-u,0)),i=0;ug;g++)if((u||g in v)&&(d=m(h=v[g],g,p),t))if(e)b[g]=d;else if(d)switch(t){case 3:return!0;case 5:return h;case 6:return g;case 2:$v(b,h)}else switch(t){case 4:return!1;case 7:$v(b,h)}return o?-1:r||i?i:b}},Pv={forEach:Ev(0),map:Ev(1),filter:Ev(2),some:Ev(3),every:Ev(4),find:Ev(5),findIndex:Ev(6),filterReject:Ev(7)},Lv=Pv.map;bu({target:"Array",proto:!0,forced:!Zp("map")},{map:function(t){return Lv(this,t,arguments.length>1?arguments[1]:void 0)}});var Av=Or,Cv=Pn,Tv=Wr,Rv=jn,Iv=yh,Nv=Va,Wv=Qo,Fv=Nn,zv=aa,Hv=Object.assign,Yv=Object.defineProperty,Uv=Cv([].concat),Bv=!Hv||Rv((function(){if(Av&&1!==Hv({b:1},Hv(Yv({},"a",{enumerable:!0,get:function(){Yv(this,"b",{value:3,enumerable:!1})}}),{b:2})).b)return!0;var t={},e={},n=Symbol("assign detection"),r="abcdefghijklmnopqrst";return t[n]=7,r.split("").forEach((function(t){e[t]=t})),7!==Hv({},t)[n]||Iv(Hv({},e)).join("")!==r}))?function(t,e){for(var n=Fv(t),r=arguments.length,i=1,o=Nv.f,a=Wv.f;r>i;)for(var u,s=zv(arguments[i++]),c=o?Uv(Iv(s),o(s)):Iv(s),l=c.length,f=0;l>f;)u=c[f++],Av&&!Tv(a,s,u)||(n[u]=s[u]);return n}:Hv,Gv=Bv;bu({target:"Object",stat:!0,arity:2,forced:Object.assign!==Gv},{assign:Gv});var Vv={exports:{}},qv={},Kv=Ma,Zv=La,Jv=Gp,Qv=Array,Xv=Math.max,ty=function(t,e,n){for(var r=Zv(t),i=Kv(e,r),o=Kv(void 0===n?r:n,r),a=Qv(Xv(o-i,0)),u=0;i1&&void 0!==arguments[1]?arguments[1]:vm.SCROLL_NONE,r=this.calendar.options.options,i=this.calendar.templateCollection,o=r.date.min?i.get(r.domain.type).extractUnit(+r.date.min):void 0,a=r.date.max?i.get(r.domain.type).extractUnit(+r.date.max):void 0,u=this.calendar.domainCollection;return hv(this,gm,"m",wm).call(this,t,o,a,n)?vm.SCROLL_NONE:(n!==vm.SCROLL_NONE&&t.clamp(o,a).slice(r.range,n===vm.SCROLL_FORWARD),u.merge(t,r.range,(function(n,o){var a=null;return a=t.at(o+1)?t.at(o+1):e.calendar.dateHelper.intervals(r.domain.type,n,2).pop(),i.get(r.subDomain.type).mapping(n,a).map((function(t){return Object.assign(Object.assign({},t),{v:r.data.defaultValue})}))})),hv(this,gm,"m",bm).call(this,u.min,u.max,o,a),n===vm.SCROLL_BACKWARD?this.calendar.eventEmitter.emit("domainsLoaded",[u.min]):n===vm.SCROLL_FORWARD&&this.calendar.eventEmitter.emit("domainsLoaded",[u.max]),n)}},{key:"jumpTo",value:function(t,e){var n=this.calendar,r=n.domainCollection,i=n.options,o=new Date(r.min),a=new Date(r.max);return ta?this.loadNewDomains(this.calendar.createDomainCollection(a,t,!1),vm.SCROLL_FORWARD):vm.SCROLL_NONE}}]),t}();gm=new WeakSet,wm=function(t,e,n,r){return!!(n&&t.max>=n&&this.maxDomainReached&&r===vm.SCROLL_FORWARD)||!!(e&&t.min<=e&&this.minDomainReached&&r===vm.SCROLL_BACKWARD)},bm=function(t,e,n,r){if(n){var i=t<=n;this.calendar.eventEmitter.emit(i?"minDateReached":"minDateNotReached"),this.minDomainReached=i}if(r){var o=e>=r;this.calendar.eventEmitter.emit(o?"maxDateReached":"maxDateNotReached"),this.maxDomainReached=o}};var Sm=TypeError,jm=bu,_m=jn,Mm=Hp,Dm=jr,$m=Nn,Em=La,Pm=function(t){if(t>9007199254740991)throw Sm("Maximum allowed index exceeded");return t},Lm=Gp,Am=kv,Cm=Zp,Tm=tr,Rm=pr("isConcatSpreadable"),Im=Tm>=51||!_m((function(){var t=[];return t[Rm]=!1,t.concat()[0]!==t})),Nm=function(t){if(!Dm(t))return!1;var e=t[Rm];return void 0!==e?!!e:Mm(t)};jm({target:"Array",proto:!0,arity:1,forced:!Im||!Cm("concat")},{concat:function(t){var e,n,r,i,o,a=$m(this),u=Am(a,0),s=0;for(e=-1,r=arguments.length;e1?arguments[1]:void 0);e=e?e.next:n.first;)for(r(e.value,e.key,this);e&&e.removed;)e=e.previous},has:function(t){return!!s(this,t)}}),qm(o,n?{get:function(t){var e=s(this,t);return e&&e.value},set:function(t,e){return u(this,0===t?0:t,e)}}:{add:function(t){return u(this,t=0===t?0:t,t)}}),ng&&Vm(o,"size",{configurable:!0,get:function(){return a(this).size}}),i},setStrong:function(t,e,n){var r=e+" Iterator",i=og(e),o=og(r);Xm(t,e,(function(t,e){ig(this,{type:r,target:t,state:i(t),kind:e,last:void 0})}),(function(){for(var t=o(this),e=t.kind,n=t.last;n&&n.removed;)n=n.previous;return t.target&&(t.last=n=n?n.next:t.state.first)?tg("keys"===e?n.key:"values"===e?n.value:[n.key,n.value],!1):(t.target=void 0,tg(void 0,!0))}),n?"entries":"values",!n,!0),eg(e)}};qy("Map",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),ag);var ug=Zr,sg=TypeError,cg=ty,lg=Math.floor,fg=function(t,e){var n=t.length,r=lg(n/2);return n<8?hg(t,e):dg(t,fg(cg(t,0,r),e),fg(cg(t,r),e),e)},hg=function(t,e){for(var n,r,i=t.length,o=1;o0;)t[r]=t[--r];r!==o++&&(t[r]=n)}return t},dg=function(t,e,n,r){for(var i=e.length,o=n.length,a=0,u=0;a3)){if(Pg)return!0;if(Ag)return Ag<603;var t,e,n,r,i="";for(t=65;t<76;t++){switch(e=String.fromCharCode(t),t){case 66:case 69:case 70:case 72:n=3;break;case 68:case 71:n=4;break;default:n=2}for(r=0;r<47;r++)Cg.push({k:e+r,v:n})}for(Cg.sort((function(t,e){return e.v-t.v})),r=0;r_g(n)?1:-1}}(t)),n=Sg(i),r=0;r1?arguments[1]:void 0)},Kg=Ki,Zg=function(t){if(t&&t.forEach!==qg)try{Kg(t,"forEach",qg)}catch(e){t.forEach=qg}};for(var Jg in Gg)Gg[Jg]&&Zg(Bg[Jg]&&Bg[Jg].prototype);function Qg(t){return"top"===t||"bottom"===t}function Xg(t){return t[ym.LEFT]+t[ym.RIGHT]}function tw(t){return t[ym.TOP]+t[ym.BOTTOM]}Zg(Vg);var ew,nw,rw=function(){function t(e,n){en(this,t),zg.add(this),this.calendar=e,this.domainPainter=n,this.collection=new Map,this.scrollDirection=vm.SCROLL_FORWARD}return rn(t,[{key:"get",value:function(t){return this.collection.get(t)}},{key:"update",value:function(t,e){var n=this,r=this.calendar.options.options,i=r.verticalOrientation,o=r.domain;this.scrollDirection=e;var a={width:0,height:0},u=0,s=e===vm.SCROLL_FORWARD?-1:1,c=t.keys;return"desc"===this.calendar.options.options.domain.sort&&(c.reverse(),s*=-1),t.yankedDomains.forEach((function(t){u+=n.collection.get(t)[i?"height":"width"]})),t.yankedDomains.forEach((function(t){var e=n.collection.get(t);n.collection.set(t,Object.assign(Object.assign({},e),{x:i?e.x:e.x+u*s,y:i?e.y+u*s:e.y}))})),c.forEach((function(t){var e=hv(n,zg,"m",Hg).call(n,t),r=hv(n,zg,"m",Yg).call(n,t);i?(a.height+=r,a.width=Math.max(e,a.width)):(a.width+=e,a.height=Math.max(r,a.height));var c=a.width-e,l=a.height-r;n.collection.set(t,Object.assign(Object.assign({},n.collection.get(t)),{x:i?0:c,y:i?l:0,pre_x:i?c:c-u*s,pre_y:i?l-u*s:l,width:e,height:r,inner_width:e-(i?0:o.gutter),inner_height:r-(i?o.gutter:0)}))})),a}}]),t}();zg=new WeakSet,Hg=function(t){var e=this.calendar.options.options,n=e.domain,r=e.subDomain,i=e.x,o=e.verticalOrientation,a=this.calendar.templateCollection.get(r.type).columnsCount(t),u=(r.width+r.gutter)*a-r.gutter;return Xg(n.padding)+i.domainHorizontalLabelWidth+(o?0:n.gutter)+u},Yg=function(t){var e=this.calendar.options.options,n=e.domain,r=e.subDomain,i=e.x,o=e.verticalOrientation,a=this.calendar.templateCollection.get(r.type).rowsCount(t),u=(r.height+r.gutter)*a-r.gutter;return tw(n.padding)+u+(o?n.gutter:0)+i.domainVerticalLabelHeight};var iw=".ch-domain",ow=function(){function t(e){en(this,t),ew.add(this),this.calendar=e,this.coordinates=new rw(e,this),this.root=null,this.dimensions={width:0,height:0}}return rn(t,[{key:"paint",value:function(t,e){var n=this,r=this.calendar.options.options.animationDuration,i=e.transition().duration(r),o=this.coordinates;this.dimensions=o.update(this.calendar.domainCollection,t);var a=[];return this.root=e.selectAll(iw).data(this.calendar.domainCollection.keys,(function(t){return t})).join((function(t){return t.append("svg").attr("x",(function(t){return o.get(t).pre_x})).attr("y",(function(t){return o.get(t).pre_y})).attr("width",(function(t){return o.get(t).inner_width})).attr("height",(function(t){return o.get(t).inner_height})).attr("class",(function(t){return hv(n,ew,"m",nw).call(n,t)})).call((function(t){return t.append("rect").attr("width",(function(t){return o.get(t).inner_width})).attr("height",(function(t){return o.get(t).inner_height})).attr("class","".concat(iw.slice(1),"-bg"))})).call((function(t){return a.push(t.transition(i).attr("x",(function(t){return o.get(t).x})).attr("y",(function(t){return o.get(t).y})).end())}))}),(function(t){return t.call((function(t){return a.push(t.transition(i).attr("x",(function(t){return o.get(t).x})).attr("y",(function(t){return o.get(t).y})).attr("width",(function(t){return o.get(t).inner_width})).attr("height",(function(t){return o.get(t).inner_height})).end())})).call((function(t){return a.push(t.selectAll("".concat(iw,"-bg")).transition(i).attr("width",(function(t){return o.get(t).inner_width})).attr("height",(function(t){return o.get(t).inner_height})).end())}))}),(function(t){return t.call((function(t){return a.push(t.transition(i).attr("x",(function(t){return o.get(t).x})).attr("y",(function(t){return o.get(t).y})).remove().end())}))})),a}}]),t}();ew=new WeakSet,nw=function(t){var e=iw.slice(1),n=this.calendar.dateHelper.date(t);switch(this.calendar.options.options.domain.type){case"hour":e+=" h_".concat(n.hour());break;case"day":e+=" d_".concat(n.date()," dy_").concat(n.format("d")+1);break;case"week":e+=" w_".concat(n.week());break;case"month":e+=" m_".concat(n.month()+1);break;case"year":e+=" y_".concat(n.year())}return e};var aw=Ia.includes,uw=Gh;bu({target:"Array",proto:!0,forced:jn((function(){return!Array(1).includes()}))},{includes:function(t){return aw(this,t,arguments.length>1?arguments[1]:void 0)}}),uw("includes");var sw=Pv.filter;bu({target:"Array",proto:!0,forced:!Zp("filter")},{filter:function(t){return sw(this,t,arguments.length>1?arguments[1]:void 0)}});var cw,lw,fw,hw,dw=Rr,pw=wf,vw=Ds,yw=Wr,mw=Nn,gw=function(t,e,n,r){try{return r?e(dw(n)[0],n[1]):e(n)}catch(e){pw(t,"throw",e)}},ww=ef,bw=cs,xw=La,Ow=Gp,kw=vf,Sw=sf,jw=Array,_w=function(t){var e=mw(t),n=bw(this),r=arguments.length,i=r>1?arguments[1]:void 0,o=void 0!==i;o&&(i=vw(i,r>2?arguments[2]:void 0));var a,u,s,c,l,f,h=Sw(e),d=0;if(!h||this===jw&&ww(h))for(a=xw(e),u=n?new this(a):jw(a);a>d;d++)f=o?i(e[d],d):e[d],Ow(u,d,f);else for(l=(c=kw(e,h)).next,u=n?new this:[];!(s=yw(l,c)).done;d++)f=o?gw(c,i,[s.value,d],!0):s.value,Ow(u,d,f);return u.length=d,u};bu({target:"Array",stat:!0,forced:!Nf((function(t){Array.from(t)}))},{from:_w});var Mw,Dw,$w,Ew,Pw,Lw,Aw,Cw={year:"YYYY",month:"MMMM",week:"wo [week] YYYY",xDay:"Do MMM",ghDay:"Do MMM",day:"Do MMM",hour:"HH:00",minute:"HH:mm"},Tw=function(){function t(e,n,r,i){var o=arguments.length>4&&void 0!==arguments[4]&&arguments[4];if(en(this,t),cw.add(this),this.collection=new Map,this.dateHelper=e,n&&r&&i){var a=this.dateHelper.intervals(n,r,i,o).map((function(t){return yv(t)}));this.collection=new Map(a)}this.min=0,this.max=0,this.keys=[],this.yankedDomains=[],this.collection.size>0&&hv(this,cw,"m",hw).call(this)}return rn(t,[{key:"has",value:function(t){return this.collection.has(t)}},{key:"get",value:function(t){return this.collection.get(t)}},{key:"forEach",value:function(t){return this.collection.forEach(t)}},{key:"at",value:function(t){return this.keys[t]}},{key:"clamp",value:function(t,e){var n=this;return t&&this.mine&&this.keys.filter((function(t){return t>e})).forEach((function(t){return n.collection.delete(t)})),hv(this,cw,"m",hw).call(this),this}},{key:"merge",value:function(t,e,n){var r=this;this.yankedDomains=[],t.keys.forEach((function(t,i){if(!r.has(t)){if(r.collection.size>=e){var o=r.max;t>r.max&&(o=r.min),o&&r.collection.delete(o)&&r.yankedDomains.push(o)}r.collection.set(t,n(t,i)),hv(r,cw,"m",hw).call(r)}})),this.yankedDomains=this.yankedDomains.sort((function(t,e){return t-e}))}},{key:"slice",value:function(){var t=this,e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=!(arguments.length>1&&void 0!==arguments[1])||arguments[1];this.keys.length>e&&((n?this.keys.slice(0,-e):this.keys.slice(e)).forEach((function(e){t.collection.delete(e)})),hv(this,cw,"m",hw).call(this));return this}},{key:"fill",value:function(t,e,n){var r=this,i=e.x,o=e.y,a=e.groupY,u=e.defaultValue,s=this.groupRecords(t,i,n);this.keys.forEach((function(t){var e=s.get(t)||{};hv(r,cw,"m",lw).call(r,t,e,o,a,u)}))}},{key:"groupRecords",value:function(t,e,n){var r=this,i=new Map,o=new Map;return this.keys.forEach((function(t){r.get(t).forEach((function(e){o.set(e.t,t)}))})),t.forEach((function(t){var a=r.extractTimestamp(t,e,n);if(o.has(a)){var u=o.get(a),s=i.get(u)||{};s[a]||(s[a]=[]),s[a].push(t),i.set(u,s)}})),i}},{key:"groupValues",value:function(t,e){var n=t.filter((function(t){return null!==t}));if("string"==typeof e){if(n.every((function(t){return"number"==typeof t})))switch(e){case"sum":return n.reduce((function(t,e){return t+e}),0);case"count":return n.length;case"min":return Math.min.apply(Math,an(n))||null;case"max":return Math.max.apply(Math,an(n))||null;case"average":return n.length>0?n.reduce((function(t,e){return t+e}),0)/n.length:null;default:return null}return"count"===e?n.length:null}return"function"==typeof e?e(n):null}},{key:"extractTimestamp",value:function(t,e,n){var r="function"==typeof e?e(t):t[e];return"string"==typeof r&&(r=+new Date(r)),n(r)}}]),t}();cw=new WeakSet,lw=function(t,e,n,r,i){var o=this;this.get(t).forEach((function(a,u){var s=i;e.hasOwnProperty(a.t)&&(s=o.groupValues(hv(o,cw,"m",fw).call(o,e[a.t],n),r)),o.get(t)[u].v=s}))},fw=function(t,e){return t.map((function(t){return"function"==typeof e?e(t):t[e]}))},hw=function(){this.keys=Array.from(this.collection.keys()).map((function(t){return parseInt(t,10)})).sort((function(t,e){return t-e}));var t=this.keys;return this.min=t[0],this.max=t[t.length-1],this.keys};var Rw=".ch-domain-text",Iw=function(){function t(e){en(this,t),Mw.add(this),this.calendar=e}return rn(t,[{key:"paint",value:function(t){var e=this,n=this.calendar.options.options.domain,r=n.label,i=n.type,o=this.calendar.dateHelper,a=r.text;null!==a&&""!==a&&(void 0===a&&(a=Cw[i]),t.selectAll(Rw).data((function(t){return[t]}),(function(t){return t})).join((function(t){return t.append("text").attr("class",Rw.slice(1)).attr("x",(function(t){return hv(e,Mw,"m",$w).call(e,t)})).attr("y",(function(t){return hv(e,Mw,"m",Ew).call(e,t)})).attr("text-anchor",r.textAlign).attr("dominant-baseline",(function(){return hv(e,Mw,"m",Dw).call(e)})).text((function(t,e,n){return o.format(t,a,n[e])})).call((function(t){return hv(e,Mw,"m",Aw).call(e,t)}))}),(function(t){t.attr("x",(function(t){return hv(e,Mw,"m",$w).call(e,t)})).attr("y",(function(t){return hv(e,Mw,"m",Ew).call(e,t)})).attr("text-anchor",r.textAlign).attr("dominant-baseline",(function(){return hv(e,Mw,"m",Dw).call(e)})).text((function(t,e,n){return o.format(t,a,n[e])})).call((function(t){return hv(e,Mw,"m",Aw).call(e,t)}))})))}}]),t}();Mw=new WeakSet,Dw=function(){var t=this.calendar.options.options.domain.label,e=t.position,n=t.rotate;return Qg(e)?"middle":"left"===n&&"left"===e||"right"===n&&"right"===e?"bottom":"hanging"},$w=function(t){var e=this.calendar.options.options.domain,n=e.padding,r=e.label,i=r.position,o=r.textAlign,a=r.offset,u=this.calendar.options.options.x.domainHorizontalLabelWidth,s=n[ym.LEFT];return"right"===i&&(s+=hv(this,Mw,"m",Pw).call(this,t)),"middle"===o&&(["top","bottom"].includes(i)?s+=hv(this,Mw,"m",Pw).call(this,t)/2:s+=u/2),"end"===o&&(Qg(i)?s+=hv(this,Mw,"m",Pw).call(this,t):s+=u),s+a.x},Ew=function(t){var e=this.calendar.options.options,n=e.domain,r=n.label,i=r.position,o=r.offset,a=n.padding,u=e.x,s=a[ym.TOP]+u.domainVerticalLabelHeight/2;return"bottom"===i&&(s+=hv(this,Mw,"m",Lw).call(this,t)),s+o.y},Pw=function(t){var e=this.calendar.options.options,n=e.domain.padding,r=e.x.domainHorizontalLabelWidth;return this.calendar.calendarPainter.domainsContainerPainter.domainPainter.coordinates.get(t).inner_width-r-Xg(n)},Lw=function(t){var e=this.calendar.options.options,n=e.x.domainVerticalLabelHeight,r=e.domain.padding;return this.calendar.calendarPainter.domainsContainerPainter.domainPainter.coordinates.get(t).inner_height-n-tw(r)},Aw=function(t){var e=this,n=this.calendar.options.options,r=n.domain.label,i=r.rotate,o=r.textAlign,a=r.position,u=n.x.domainHorizontalLabelWidth;switch(i){case"right":t.attr("transform",(function(t){var n=hv(e,Mw,"m",Pw).call(e,t),r=hv(e,Mw,"m",Lw).call(e,t),i=["rotate(90, ".concat("right"===a?n:u,", 0)")];switch(a){case"right":"middle"===o?i.push("translate(".concat(r/2-u/2,")")):"end"===o&&i.push("translate(".concat(r-u,")"));break;case"left":"start"===o?i.push("translate(".concat(u,")")):"middle"===o?i.push("translate(".concat(u/2+r/2,")")):"end"===o&&i.push("translate(".concat(r,")"))}return i.join(",")}));break;case"left":t.attr("transform",(function(t){var n=hv(e,Mw,"m",Pw).call(e,t),r=hv(e,Mw,"m",Lw).call(e,t),i=["rotate(270, ".concat("right"===a?n:u,", 0)")];switch(a){case"right":"start"===o?i.push("translate(-".concat(r,")")):"middle"===o?i.push("translate(-".concat(r/2+u/2,")")):"end"===o&&i.push("translate(-".concat(u,")"));break;case"left":"start"===o?i.push("translate(".concat(u-r,")")):"middle"===o&&i.push("translate(".concat(u/2-r/2,")"))}return i.join(",")}))}};var Nw,Ww,Fw,zw,Hw,Yw,Uw,Bw="\t\n\v\f\r                　\u2028\u2029\ufeff",Gw=Tn,Vw=ip,qw=Bw,Kw=Pn("".replace),Zw=RegExp("^["+qw+"]+"),Jw=RegExp("(^|[^"+qw+"])["+qw+"]+$"),Qw=function(t){return function(e){var n=Vw(Gw(e));return 1&t&&(n=Kw(n,Zw,"")),2&t&&(n=Kw(n,Jw,"$1")),n}},Xw={start:Qw(1),end:Qw(2),trim:Qw(3)},tb=Ti.PROPER,eb=jn,nb=Bw,rb=Xw.trim;bu({target:"String",proto:!0,forced:function(t){return eb((function(){return!!nb[t]()||"​…᠎"!=="​…᠎"[t]()||tb&&nb[t].name!==t}))}("trim")},{trim:function(){return rb(this)}});var ib,ob,ab,ub,sb=".ch-subdomain",cb=function(){function t(e){en(this,t),Nw.add(this),this.calendar=e,this.root=null}return rn(t,[{key:"paint",value:function(t){var e=this;this.root=t||this.root;var n="".concat(sb,"-container"),r=this.root.selectAll(n).data((function(t){return[t]}),(function(t){return t})).join((function(t){return t.append("svg").call((function(t){return hv(e,Nw,"m",Ww).call(e,t)})).attr("class",n.slice(1))}),(function(t){return t.call((function(t){return hv(e,Nw,"m",Ww).call(e,t)}))})),i=this.calendar.options.options.subDomain,o=i.radius,a=i.width,u=i.height,s=i.sort,c=this.calendar.eventEmitter;r.selectAll("g").data((function(t){var n=e.calendar.domainCollection.get(t);if("desc"===s){var r=Math.max.apply(Math,an(n.map((function(t){return t.x}))));n.forEach((function(t,e){n[e].x=Math.abs(t.x-r)}))}return n})).join((function(t){return t.append("g").call((function(t){return t.insert("rect").attr("class",(function(t){return hv(e,Nw,"m",Fw).call(e,t.t,"".concat(sb.slice(1),"-bg"))})).attr("width",a).attr("height",u).attr("x",(function(t){return hv(e,Nw,"m",Yw).call(e,t)})).attr("y",(function(t){return hv(e,Nw,"m",Uw).call(e,t)})).on("click",(function(t,e){return c.emit("click",t,e.t,e.v)})).on("mouseover",(function(t,e){return c.emit("mouseover",t,e.t,e.v)})).on("mouseout",(function(t,e){return c.emit("mouseout",t,e.t,e.v)})).attr("rx",o>0?o:null).attr("ry",o>0?o:null)})).call((function(t){return hv(e,Nw,"m",zw).call(e,t)}))}),(function(t){return t.selectAll("rect").attr("class",(function(t){return hv(e,Nw,"m",Fw).call(e,t.t,"".concat(sb.slice(1),"-bg"))})).attr("width",a).attr("height",u).attr("x",(function(t){return hv(e,Nw,"m",Yw).call(e,t)})).attr("y",(function(t){return hv(e,Nw,"m",Uw).call(e,t)})).attr("rx",o).attr("ry",o)}))}}]),t}();Nw=new WeakSet,Ww=function(t){var e=this.calendar.options.options,n=e.domain,r=n.padding,i=n.label.position;t.attr("x",(function(){var t=r[ym.LEFT];return"left"===i&&(t+=e.x.domainHorizontalLabelWidth),t})).attr("y",(function(){var t=r[ym.TOP];return"top"===i&&(t+=e.x.domainVerticalLabelHeight),t}))},Fw=function(t){var e=this,n=this.calendar.options.options,r=n.date.highlight,i=n.subDomain.type,o="";r.length>0&&r.forEach((function(n){var r=e.calendar.templateCollection.get(i).extractUnit;r(+n)===r(t)&&(o="highlight")}));for(var a=arguments.length,u=new Array(a>1?a-1:0),s=1;s0&&void 0!==arguments[0]?arguments[0]:vm.SCROLL_NONE,e=this.domainsContainerPainter.paint(t).concat(this.pluginPainter.paint()).concat(this.domainsContainerPainter.updatePosition());return hv(this,db,"m",yb).call(this),Promise.allSettled(e)}},{key:"destroy",value:function(){var t=this.calendar.pluginManager.destroyAll().concat(this.domainsContainerPainter.destroy());return this.root?(t.push(this.root.transition().duration(this.calendar.options.options.animationDuration).attr("width",0).attr("height",0).remove().end()),Promise.allSettled(t)):Promise.allSettled(t)}}]),e}();db=new WeakSet,pb=function(){return this.domainsContainerPainter.height()+this.pluginPainter.insideHeight()},vb=function(){return this.domainsContainerPainter.width()+this.pluginPainter.insideWidth()},yb=function(){var t=this.calendar.options.options,e=hv(this,db,"m",vb).call(this),n=hv(this,db,"m",pb).call(this);this.root.transition().duration(t.animationDuration).attr("width",e).attr("height",n),e===this.dimensions.width&&n===this.dimensions.height||this.calendar.eventEmitter.emit("resize",e,n,this.dimensions.width,this.dimensions.height),this.dimensions={width:e,height:n}};var wb="object"==typeof global&&global&&global.Object===Object&&global,bb="object"==typeof self&&self&&self.Object===Object&&self,xb=wb||bb||Function("return this")(),Ob=xb.Symbol,kb=Object.prototype,Sb=kb.hasOwnProperty,jb=kb.toString,_b=Ob?Ob.toStringTag:void 0;var Mb=Object.prototype.toString;var Db="[object Null]",$b="[object Undefined]",Eb=Ob?Ob.toStringTag:void 0;function Pb(t){return null==t?void 0===t?$b:Db:Eb&&Eb in Object(t)?function(t){var e=Sb.call(t,_b),n=t[_b];try{t[_b]=void 0;var r=!0}catch(t){}var i=jb.call(t);return r&&(e?t[_b]=n:delete t[_b]),i}(t):function(t){return Mb.call(t)}(t)}function Lb(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)}var Ab="[object AsyncFunction]",Cb="[object Function]",Tb="[object GeneratorFunction]",Rb="[object Proxy]";function Ib(t){if(!Lb(t))return!1;var e=Pb(t);return e==Cb||e==Tb||e==Ab||e==Rb}var Nb=Nn,Wb=yh;bu({target:"Object",stat:!0,forced:jn((function(){Wb(1)}))},{keys:function(t){return Wb(Nb(t))}});var Fb,zb=jr,Hb=zo,Yb=pr("match"),Ub=function(t){var e;return zb(t)&&(void 0!==(e=t[Yb])?!!e:"RegExp"===Hb(t))},Bb=TypeError,Gb=function(t){if(Ub(t))throw new Bb("The method doesn't accept regular expressions");return t},Vb=pr("match"),qb=function(t){var e=/./;try{"/./"[t](e)}catch(n){try{return e[Vb]=!1,"/./"[t](e)}catch(t){}}return!1},Kb=bu,Zb=Ss,Jb=Jo.f,Qb=Ea,Xb=ip,tx=Gb,ex=Tn,nx=qb,rx=Zb("".startsWith),ix=Zb("".slice),ox=Math.min,ax=nx("startsWith");Kb({target:"String",proto:!0,forced:!!(ax||(Fb=Jb(String.prototype,"startsWith"),!Fb||Fb.writable))&&!ax},{startsWith:function(t){var e=Xb(ex(this));tx(t);var n=Qb(ox(arguments.length>1?arguments[1]:void 0,e.length)),r=Xb(t);return rx?rx(e,r,n):ix(e,n,n+r.length)===r}});var ux=Or,sx=jn,cx=Pn,lx=ed,fx=yh,hx=ca,dx=cx(Qo.f),px=cx([].push),vx=ux&&sx((function(){var t=Object.create(null);return t[2]=2,!dx(t,2)})),yx=function(t){return function(e){for(var n,r=hx(e),i=fx(r),o=vx&&null===lx(r),a=i.length,u=0,s=[];a>u;)n=i[u++],ux&&!(o?n in r:dx(r,n))||px(s,t?[n,r[n]]:r[n]);return s}},mx={entries:yx(!0),values:yx(!1)}.entries;function gx(t){return null!=t&&!Number.isNaN(t)}function wx(t,e){return+gx(e)-+gx(t)||n(t,e)}function bx(t){return isFinite(t)?t:NaN}function xx(t){return t>0&&isFinite(t)?t:NaN}function Ox(t){return t<0&&isFinite(t)?t:NaN}bu({target:"Object",stat:!0},{entries:function(t){return mx(t)}});const kx=/^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/;function Sx(t,e){return kx.test(t+="")?new Date(t):"function"==typeof e?e(t):e}const jx=new Map([["second",r],["minute",i],["hour",o],["day",a],["week",u],["month",s],["quarter",s.every(3)],["half",s.every(6)],["year",c],["monday",l],["tuesday",f],["wednesday",h],["thursday",d],["friday",p],["saturday",v],["sunday",y]]),_x=new Map([["second",m],["minute",g],["hour",w],["day",b],["week",x],["month",O],["quarter",O.every(3)],["half",O.every(6)],["year",k],["monday",S],["tuesday",j],["wednesday",_],["thursday",M],["friday",D],["saturday",$],["sunday",E]]);function Mx(t){const e=jx.get(`${t}`.toLowerCase());if(!e)throw new Error(`unknown interval: ${t}`);return e}function Dx(t){const e=_x.get(`${t}`.toLowerCase());if(!e)throw new Error(`unknown interval: ${t}`);return e}const $x=Object.getPrototypeOf(Uint8Array),Ex=Object.prototype.toString,Px=t=>()=>t;function Lx(t){return t instanceof $x?t:Ix(t,Ax,Float64Array)}function Ax(t){return null==t?NaN:Number(t)}function Cx(t){return Ix(t,Tx)}function Tx(t){return t instanceof Date&&!isNaN(t)?t:"string"==typeof t?Sx(t):null==t||isNaN(t=+t)?void 0:new Date(t)}function Rx(t){return null==t||t instanceof Array||t instanceof $x?t:Array.from(t)}function Ix(t,e,n=Array){return null==t?t:t instanceof n?t.map(e):n.from(t,e)}function Nx(t,e=Array){return t instanceof e?t.slice():e.from(t)}function Wx(t){return function(t){return t?.toString===Ex}(t)&&(void 0!==t.type||void 0!==t.domain)}function Fx(t,e){if(null!=t){if("number"==typeof t){0Math.floor(t*e)/e,offset:t=>(t*e+1)/e,range:(t,n)=>L(Math.ceil(t*e),n*e).map((t=>t/e))}:{floor:t=>Math.floor(t/e)*e,offset:t=>t+e,range:(t,n)=>L(Math.ceil(t/e),n/e).map((t=>t*e))}}if("string"==typeof t)return("time"===e?Mx:Dx)(t);if("function"!=typeof t.floor)throw new Error("invalid interval; missing floor method");if("function"!=typeof t.offset)throw new Error("invalid interval; missing offset method");return t}}function zx(t,e){if((t=Fx(t,e))&&"function"!=typeof t.range)throw new Error("invalid interval: missing range method");return t}function Hx(t){for(const e of t){if(null==e)continue;const t=typeof e;return"string"===t||"boolean"===t}}function Yx(t){for(const e of t)if(null!=e)return e instanceof Date}function Ux(t){for(const e of t)if(null!=e)return"string"==typeof e&&isNaN(e)&&Sx(e)}function Bx(t){for(const e of t)if(null!=e){if("string"!=typeof e)return!1;if(e.trim())return!isNaN(e)}}function Gx(t){if(null==t)return;const e=t[0],n=t[t.length-1];return P(e,n)}const Vx=Symbol("position"),qx=Symbol("color"),Kx=Symbol("radius"),Zx=Symbol("length"),Jx=Symbol("opacity"),Qx=Symbol("symbol"),Xx=new Map([["x",Vx],["y",Vx],["fx",Vx],["fy",Vx],["r",Kx],["color",qx],["opacity",Jx],["symbol",Qx],["length",Zx]]),tO=2/Math.sqrt(3),eO=new Map([["asterisk",A],["circle",C],["cross",T],["diamond",R],["diamond2",I],["hexagon",{draw(t,e){const n=Math.sqrt(e/Math.PI),r=n*tO,i=r/2;t.moveTo(0,r),t.lineTo(n,i),t.lineTo(n,-i),t.lineTo(0,-r),t.lineTo(-n,-i),t.lineTo(-n,i),t.closePath()}}],["plus",N],["square",W],["square2",F],["star",z],["times",H],["triangle",Y],["triangle2",U],["wye",B]]);function nO(t){if(null==t||function(t){return t&&"function"==typeof t.draw}(t))return t;const e=eO.get(`${t}`.toLowerCase());if(e)return e;throw new Error(`invalid symbol: ${t}`)}function rO(t){console.warn(t)}const iO=new Map([["accent",G],["category10",V],["dark2",q],["paired",K],["pastel1",Z],["pastel2",J],["set1",Q],["set2",X],["set3",tt],["tableau10",et],["brbg",aO(zt,rt)],["prgn",aO(Ht,it)],["piyg",aO(Yt,ot)],["puor",aO(Ut,at)],["rdbu",aO(Bt,ut)],["rdgy",aO(Gt,st)],["rdylbu",aO(Vt,ct)],["rdylgn",aO(qt,lt)],["spectral",aO(Kt,ft)],["burd",uO(Bt,ut)],["buylrd",uO(Vt,ct)],["blues",oO(Zt,ht)],["greens",oO(Jt,dt)],["greys",oO(Qt,pt)],["oranges",oO(Xt,mt)],["purples",oO(te,vt)],["reds",oO(ee,yt)],["turbo",sO(gt)],["viridis",sO(wt)],["magma",sO(bt)],["inferno",sO(xt)],["plasma",sO(Ot)],["cividis",sO(kt)],["cubehelix",sO(St)],["warm",sO(jt)],["cool",sO(_t)],["bugn",oO(ne,Mt)],["bupu",oO(re,Dt)],["gnbu",oO(ie,$t)],["orrd",oO(oe,Et)],["pubu",oO(ae,Lt)],["pubugn",oO(ue,Pt)],["purd",oO(se,At)],["rdpu",oO(ce,Ct)],["ylgn",oO(le,Rt)],["ylgnbu",oO(fe,Tt)],["ylorbr",oO(he,It)],["ylorrd",oO(de,Nt)],["rainbow",cO(Wt)],["sinebow",cO(Ft)]]);function oO(t,e){return({length:n})=>1===n?[t[3][1]]:2===n?[t[3][1],t[3][2]]:(n=Math.max(3,Math.floor(n)))>9?nt(e,n):t[n]}function aO(t,e){return({length:n})=>2===n?[t[3][0],t[3][2]]:(n=Math.max(3,Math.floor(n)))>11?nt(e,n):t[n]}function uO(t,e){return({length:n})=>2===n?[t[3][2],t[3][0]]:(n=Math.max(3,Math.floor(n)))>11?nt((t=>e(1-t)),n):t[n].slice().reverse()}function sO(t){return({length:e})=>nt(t,Math.max(2,Math.floor(e)))}function cO(t){return({length:e})=>nt(t,Math.floor(e)+1).slice(0,-1)}function lO(t){const e=`${t}`.toLowerCase();if(!iO.has(e))throw new Error(`unknown ordinal scheme: ${e}`);return iO.get(e)}function fO(t,e){const n=lO(t),r="function"==typeof n?n({length:e}):n;return r.length!==e?r.slice(0,e):r}const hO=new Map([["brbg",rt],["prgn",it],["piyg",ot],["puor",at],["rdbu",ut],["rdgy",st],["rdylbu",ct],["rdylgn",lt],["spectral",ft],["burd",t=>ut(1-t)],["buylrd",t=>ct(1-t)],["blues",ht],["greens",dt],["greys",pt],["purples",vt],["reds",yt],["oranges",mt],["turbo",gt],["viridis",wt],["magma",bt],["inferno",xt],["plasma",Ot],["cividis",kt],["cubehelix",St],["warm",jt],["cool",_t],["bugn",Mt],["bupu",Dt],["gnbu",$t],["orrd",Et],["pubugn",Pt],["pubu",Lt],["purd",At],["rdpu",Ct],["ylgnbu",Tt],["ylgn",Rt],["ylorbr",It],["ylorrd",Nt],["rainbow",Wt],["sinebow",Ft]]);function dO(t){const e=`${t}`.toLowerCase();if(!hO.has(e))throw new Error(`unknown quantitative scheme: ${e}`);return hO.get(e)}const pO=new Set(["brbg","prgn","piyg","puor","rdbu","rdgy","rdylbu","rdylgn","spectral","burd","buylrd"]);function vO(t){return null!=t&&pO.has(`${t}`.toLowerCase())}const yO=t=>e=>t(1-e),mO=[0,1],gO=new Map([["number",xe],["rgb",_e],["hsl",Pe],["hcl",Le],["lab",Ae]]);function wO(t){const e=`${t}`.toLowerCase();if(!gO.has(e))throw new Error(`unknown interpolator: ${e}`);return gO.get(e)}function bO(t,e,n,{type:r,nice:i,clamp:o,zero:a,domain:u=SO(t,n),unknown:s,round:c,scheme:l,interval:f,range:h=(Xx.get(t)===Kx?_O(n,u):Xx.get(t)===Zx?MO(n,u):Xx.get(t)===Jx?mO:void 0),interpolate:d=(Xx.get(t)===qx?null==l&&void 0!==h?_e:dO(void 0!==l?l:"cyclical"===r?"rainbow":"turbo"):c?Me:xe),reverse:p}){if(f=zx(f,r),"cyclical"!==r&&"sequential"!==r||(r="linear"),p=!!p,"function"!=typeof d&&(d=wO(d)),1===d.length?(p&&(d=yO(d),p=!1),void 0===h&&2===(h=Float64Array.from(u,((t,e)=>e/(u.length-1)))).length&&(h=mO),e.interpolate((h===mO?Px:EO)(d))):e.interpolate(d),a){const[t,e]=we(u);(t>0||e<0)&&(Gx(u=Nx(u))!==Math.sign(t)?u[u.length-1]=0:u[0]=0)}return p&&(u=Oe(u)),e.domain(u).unknown(s),i&&(e.nice(function(t,e){return!0===t?void 0:"number"==typeof t?t:function(t,e){if((t=zx(t,e))&&"function"!=typeof t.ceil)throw new Error("invalid interval: missing ceil method");return t}(t,e)}(i,r)),u=e.domain()),void 0!==h&&e.range(h),o&&e.clamp(o),{type:r,domain:u,range:h,scale:e,interpolate:d,interval:f}}function xO(t,e,{exponent:n=1,...r}){return bO(t,ve().exponent(n),e,{...r,type:"pow"})}function OO(t,e,{domain:n=[0],unknown:r,scheme:i="rdylbu",interpolate:o,range:a=(void 0!==o?nt(o,n.length+1):Xx.get(t)===qx?fO(i,n.length+1):void 0),reverse:u}){const s=Gx(n=Rx(n));if(!isNaN(s)&&!function(t,e){for(let n=1,r=t.length,i=t[0];nvoid 0===t?t:De(t,e))),je(t,(({value:t})=>void 0===t?t:je(t,e)))]:[0,1]}function SO(t,e){const n=Xx.get(t);return(n===Kx||n===Jx||n===Zx?jO:kO)(e)}function jO(t){return[0,t.length?je(t,(({value:t})=>void 0===t?t:je(t,bx))):1]}function _O(t,e){const n=t.find((({radius:t})=>void 0!==t));if(void 0!==n)return[0,n.radius];const r=$e(t,.5,(({value:t})=>void 0===t?NaN:$e(t,.25,xx))),i=e.map((t=>3*Math.sqrt(t/r))),o=30/je(i);return o<1?i.map((t=>t*o)):i}function MO(t,e){const n=Ee(t,(({value:t})=>void 0===t?NaN:Ee(t,Math.abs))),r=e.map((t=>12*t/n)),i=60/je(r);return i<1?r.map((t=>t*i)):r}function DO(t){for(const{value:e}of t)if(void 0!==e)for(let n of e){if(n>0)return kO(t,xx);if(n<0)return kO(t,Ox)}return[1,10]}function $O(t){const e=[];for(const{value:n}of t)if(void 0!==n)for(const t of n)e.push(t);return e}function EO(t){return(e,n)=>r=>t(e+r*(n-e))}function PO(t,e,n,r,{type:i,nice:o,clamp:a,domain:u=kO(r),unknown:s,pivot:c=0,scheme:l,range:f,symmetric:h=!0,interpolate:d=(Xx.get(t)===qx?null==l&&void 0!==f?_e:dO(void 0!==l?l:"rdbu"):xe),reverse:p}){c=+c;let[v,y]=u;if(P(v,y)<0&&([v,y]=[y,v],p=!p),v=Math.min(v,c),y=Math.max(y,c),"function"!=typeof d&&(d=wO(d)),void 0!==f&&(d=1===d.length?EO(d)(...f):Ne(d,f)),p&&(d=yO(d)),h){const t=n.apply(c),e=t-n.apply(v),r=n.apply(y)-t;er&&(y=n.invert(t+e))}return e.domain([v,c,y]).unknown(s).interpolator(d),a&&e.clamp(a),o&&e.nice(o),{type:i,domain:[v,y],pivot:c,interpolate:d,scale:e}}function LO(t,e,{exponent:n=1,...r}){return PO(t,Te().exponent(n=+n),function(t){return.5===t?RO:{apply:e=>Math.sign(e)*Math.pow(Math.abs(e),t),invert:e=>Math.sign(e)*Math.pow(Math.abs(e),1/t)}}(n),e,{...r,type:"diverging-pow"})}function AO(t,e,{constant:n=1,...r}){return PO(t,Ie().constant(n=+n),function(t){return{apply:e=>Math.sign(e)*Math.log1p(Math.abs(e/t)),invert:e=>Math.sign(e)*Math.expm1(Math.abs(e))*t}}(n),e,r)}const CO={apply:t=>t,invert:t=>t},TO={apply:Math.log,invert:Math.exp},RO={apply:t=>Math.sign(t)*Math.sqrt(Math.abs(t)),invert:t=>Math.sign(t)*(t*t)};function IO(t,e,n,r){return bO(t,e,n,r)}const NO=Symbol("ordinal");function WO(t,e,n,{type:r,interval:i,domain:o,range:a,reverse:u,hint:s}){return i=zx(i,r),void 0===o&&(o=HO(n,i,t)),"categorical"!==r&&r!==NO||(r="ordinal"),u&&(o=Oe(o)),e.domain(o),void 0!==a&&("function"==typeof a&&(a=a(o)),e.range(a)),{type:r,domain:o,range:a,scale:e,hint:s,interval:i}}function FO(t,e,{type:n,interval:r,domain:i,range:o,scheme:a,unknown:u,...s}){let c;if(r=zx(r,n),void 0===i&&(i=HO(e,r,t)),Xx.get(t)===Qx)c=function(t){return{fill:YO(t,"fill"),stroke:YO(t,"stroke")}}(e),o=void 0===o?function(t){return e=t.fill,null==e||function(t){return/^\s*none\s*$/i.test(t)}(e)?Ve:qe;var e}(c):Ix(o,nO);else if(Xx.get(t)===qx&&(void 0!==o||"ordinal"!==n&&n!==NO||(o=function(t,e="greys"){const n=new Set,[r,i]=fO(e,2);for(const e of t)if(null!=e)if(!0===e)n.add(i);else{if(!1!==e)return;n.add(r)}return[...n]}(i,a),void 0!==o&&(a=void 0)),void 0===a&&void 0===o&&(a="ordinal"===n?"turbo":"tableau10"),void 0!==a))if(void 0!==o){const t=dO(a),e=o[0],n=o[1]-o[0];o=({length:r})=>nt((r=>t(e+n*r)),r)}else o=lO(a);if(u===ze)throw new Error(`implicit unknown on ${t} scale is not supported`);return WO(t,He().unknown(u),e,{...s,type:n,domain:i,range:o,hint:c})}function zO(t,e,n,r){let{round:i}=n;return void 0!==i&&t.round(i=!!i),(t=WO(r,t,e,n)).round=i,t}function HO(t,e,n){const r=new Be;for(const{value:e,domain:n}of t){if(void 0!==n)return n();if(void 0!==e)for(const t of e)r.add(t)}if(void 0!==e){const[t,n]=we(r).map(e.floor,e);return e.range(t,e.offset(n))}if(r.size>1e4&&Xx.get(n)===Vx)throw new Error(`implicit ordinal domain of ${n} scale has more than 10,000 values`);return Ge(r,wx)}function YO(t,e){let n;for(const{hint:r}of t){const t=r?.[e];if(void 0!==t)if(void 0===n)n=t;else if(n!==t)return}return n}function UO(t,e,n){return function(t,e=[],n={}){const r=function(t,e,{type:n,domain:r,range:i,scheme:o,pivot:a,projection:u}){if("fx"===t||"fy"===t)return"band";"x"!==t&&"y"!==t||null==u||(n=GO);for(const{type:t}of e)if(void 0!==t)if(void 0===n)n=t;else if(n!==t)throw new Error(`scale incompatible with channel: ${n} !== ${t}`);if(n===GO)return;if(void 0!==n)return n;if(void 0===r&&!e.some((({value:t})=>void 0!==t)))return;const s=Xx.get(t);if(s===Kx)return"sqrt";if(s===Jx||s===Zx)return"linear";if(s===Qx)return"ordinal";if((r||i||[]).length>2)return VO(s);if(void 0!==r)return Hx(r)?VO(s):Yx(r)?"utc":s!==qx||null==a&&!vO(o)?"linear":"diverging";const c=e.map((({value:t})=>t)).filter((t=>void 0!==t));return c.some(Hx)?VO(s):c.some(Yx)?"utc":s!==qx||null==a&&!vO(o)?"linear":"diverging"}(t,e,n);if(void 0===n.type&&void 0===n.domain&&void 0===n.range&&null==n.interval&&"fx"!==t&&"fy"!==t&&function({type:t}){return"ordinal"===t||"point"===t||"band"===t||t===NO}({type:r})){const n=e.map((({value:t})=>t)).filter((t=>void 0!==t));n.some(Yx)?rO(`Warning: some data associated with the ${t} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${BO(r)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${t} scale to "${BO(r)}".`):n.some(Ux)?rO(`Warning: some data associated with the ${t} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${BO(r)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${t} scale to "${BO(r)}".`):n.some(Bx)&&rO(`Warning: some data associated with the ${t} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${BO(r)}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${t} scale to "${BO(r)}".`)}switch(n.type=r,r){case"diverging":case"diverging-sqrt":case"diverging-pow":case"diverging-log":case"diverging-symlog":case"cyclical":case"sequential":case"linear":case"sqrt":case"threshold":case"quantile":case"pow":case"log":case"symlog":n=qO(e,n,Lx);break;case"identity":switch(Xx.get(t)){case Vx:n=qO(e,n,Lx);break;case Qx:n=qO(e,n,KO)}break;case"utc":case"time":n=qO(e,n,Cx)}switch(r){case"diverging":return function(t,e,n){return PO(t,Ce(),CO,e,n)}(t,e,n);case"diverging-sqrt":return function(t,e,n){return LO(t,e,{...n,exponent:.5})}(t,e,n);case"diverging-pow":return LO(t,e,n);case"diverging-log":return function(t,e,{base:n=10,pivot:r=1,domain:i=kO(e,r<0?Ox:xx),...o}){return PO(t,Re().base(n=+n),TO,e,{domain:i,pivot:r,...o})}(t,e,n);case"diverging-symlog":return AO(t,e,n);case"categorical":case"ordinal":case NO:return FO(t,e,n);case"cyclical":case"sequential":case"linear":return function(t,e,n){return bO(t,pe(),e,n)}(t,e,n);case"sqrt":return function(t,e,n){return xO(t,e,{...n,exponent:.5})}(t,e,n);case"threshold":return OO(t,0,n);case"quantile":return function(t,e,{range:n,quantiles:r=(void 0===n?5:(n=[...n]).length),n:i=r,scheme:o="rdylbu",domain:a=$O(e),unknown:u,interpolate:s,reverse:c}){return void 0===n&&(n=void 0!==s?nt(s,i):Xx.get(t)===qx?fO(o,i):void 0),a.length>0&&(a=ge(a,void 0===n?{length:i}:n).quantiles()),OO(t,0,{domain:a,range:n,reverse:c,unknown:u})}(t,e,n);case"quantize":return function(t,e,{range:n,n:r=(void 0===n?5:(n=[...n]).length),scheme:i="rdylbu",domain:o=SO(t,e),unknown:a,interpolate:u,reverse:s}){const[c,l]=we(o);let f;return void 0===n?(f=be(c,l,r),f[0]<=c&&f.splice(0,1),f[f.length-1]>=l&&f.pop(),r=f.length+1,n=void 0!==u?nt(u,r):Xx.get(t)===qx?fO(i,r):void 0):(f=nt(xe(c,l),r+1).slice(1,-1),c instanceof Date&&(f=f.map((t=>new Date(t))))),Gx(Rx(o))<0&&f.reverse(),OO(t,0,{domain:f,range:n,reverse:s,unknown:a})}(t,e,n);case"pow":return xO(t,e,n);case"log":return function(t,e,{base:n=10,domain:r=DO(e),...i}){return bO(t,ye().base(n),e,{...i,domain:r})}(t,e,n);case"symlog":return function(t,e,{constant:n=1,...r}){return bO(t,me().constant(n),e,r)}(t,e,n);case"utc":return function(t,e,n){return IO(t,Fe(),e,n)}(t,e,n);case"time":return function(t,e,n){return IO(t,We(),e,n)}(t,e,n);case"point":return function(t,e,{align:n=.5,padding:r=.5,...i}){return zO(Ye().align(n).padding(r),e,i,t)}(t,e,n);case"band":return function(t,e,{align:n=.5,padding:r=.1,paddingInner:i=r,paddingOuter:o=("fx"===t||"fy"===t?0:r),...a}){return zO(Ue().align(n).paddingInner(i).paddingOuter(o),e,a,t)}(t,e,n);case"identity":return Xx.get(t)===Vx?{type:"identity",scale:Se()}:{type:"identity"};case void 0:return;default:throw new Error(`unknown scale type: ${r}`)}}(t,void 0===n?void 0:[{hint:n}],{...e})}function BO(t){return"symbol"==typeof t?t.description:t}const GO={toString:()=>"projection"};function VO(t){switch(t){case Vx:return"point";case qx:return NO;default:return"ordinal"}}function qO(t,{domain:e,...n},r){for(const e of t)void 0!==e.value&&(e.value=r(e.value));return{domain:void 0===e?e:r(e),...n}}function KO(t){return Ix(t,nO)}function ZO({scale:t,type:e,domain:n,range:r,interpolate:i,interval:o,transform:a,percent:u,pivot:s}){if("identity"===e)return{type:"identity",apply:t=>t,invert:t=>t};const c=t.unknown?t.unknown():void 0;return{type:e,domain:Nx(n),...void 0!==r&&{range:Nx(r)},...void 0!==a&&{transform:a},...u&&{percent:u},...void 0!==c&&{unknown:c},...void 0!==o&&{interval:o},...void 0!==i&&{interpolate:i},...t.clamp&&{clamp:t.clamp()},...void 0!==s&&{pivot:s,symmetric:!1},...t.base&&{base:t.base()},...t.exponent&&{exponent:t.exponent()},...t.constant&&{constant:t.constant()},...t.align&&{align:t.align(),round:t.round()},...t.padding&&(t.paddingInner?{paddingInner:t.paddingInner(),paddingOuter:t.paddingOuter()}:{padding:t.padding()}),...t.bandwidth&&{bandwidth:t.bandwidth(),step:t.step()},apply:e=>t(e),...t.invert&&{invert:e=>t.invert(e)}}}function JO(t){try{var e=Object.keys(t)[0];return function(t={}){let e;for(const n in t)if(Xx.has(n)&&Wx(t[n])){if(void 0!==e)throw new Error("ambiguous scale definition; multiple scales found");e=ZO(UO(n,t[n]))}if(void 0===e)throw new Error("invalid scale definition; no scale found");return e}((n={},r=e,i=Object.assign(Object.assign({},t[e]),{clamp:!0}),(r=cn(r))in n?Object.defineProperty(n,r,{value:i,enumerable:!0,configurable:!0,writable:!0}):n[r]=i,n))}catch(t){return null}var n,r,i}function QO(t,e,n,r){Object.entries(function(t,e){var n={};return e.hasOwnProperty("opacity")?(n.fill=function(){return e.opacity.baseColor||xm},n["fill-opacity"]=function(e){return null==t?void 0:t.apply(e)}):n.fill=function(e){return"string"==typeof e&&(null==e?void 0:e.startsWith("#"))?e:null==t?void 0:t.apply(e)},n}(e,n)).forEach((function(e){var n=on(e,2),i=n[0],o=n[1];return t.style(i,(function(t){return o(r?t[r]:t)}))}))}var XO=function(){function t(e){en(this,t),this.calendar=e}return rn(t,[{key:"populate",value:function(){var t=this.calendar,n=t.options.options,r=n.scale,i=n.subDomain,o=JO(r);t.calendarPainter.root.selectAll(".ch-domain").selectAll("svg").selectAll("g").data((function(e){return t.domainCollection.get(e)||[]})).call((function(t){QO(t.select("rect"),o,r,"v")})).call((function(n){n.select("text").attr("style",(function(t){var n=e(null==o?void 0:o.apply(t.v)).l>60?"#000":"#fff",r=i.color||(t.v?n:null);return Ib(r)&&(r=r(t.t,t.v,null==o?void 0:o.apply(t.v))),r?"fill: ".concat(r,";"):null})).text((function(e,n,r){return t.dateHelper.format(e.t,i.label,e.v,r[n])}))})).call((function(){t.eventEmitter.emit("fill")}))}}]),t}();function tk(t,e){return t===e||t!=t&&e!=e}function ek(t,e){for(var n=t.length;n--;)if(tk(t[n][0],e))return n;return-1}var nk=Array.prototype.splice;function rk(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e-1},rk.prototype.set=function(t,e){var n=this.__data__,r=ek(n,t);return r<0?(++this.size,n.push([t,e])):n[r][1]=e,this};var ik=xb["__core-js_shared__"],ok=function(){var t=/[^.]+$/.exec(ik&&ik.keys&&ik.keys.IE_PROTO||"");return t?"Symbol(src)_1."+t:""}();var ak=Function.prototype.toString;function uk(t){if(null!=t){try{return ak.call(t)}catch(t){}try{return t+""}catch(t){}}return""}var sk=/^\[object .+?Constructor\]$/,ck=Function.prototype,lk=Object.prototype,fk=ck.toString,hk=lk.hasOwnProperty,dk=RegExp("^"+fk.call(hk).replace(/[\\^$.*+?()[\]{}|]/g,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");function pk(t){return!(!Lb(t)||(e=t,ok&&ok in e))&&(Ib(t)?dk:sk).test(uk(t));var e}function vk(t,e){var n=function(t,e){return null==t?void 0:t[e]}(t,e);return pk(n)?n:void 0}var yk=vk(xb,"Map"),mk=vk(Object,"create");var gk=Object.prototype.hasOwnProperty;var wk=Object.prototype.hasOwnProperty;function bk(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e-1&&t%1==0&&t<=Kk}function Jk(t){return null!=t&&Zk(t.length)&&!Ib(t)}var Qk="object"==typeof exports&&exports&&!exports.nodeType&&exports,Xk=Qk&&"object"==typeof module&&module&&!module.nodeType&&module,tS=Xk&&Xk.exports===Qk?xb.Buffer:void 0,eS=(tS?tS.isBuffer:void 0)||function(){return!1},nS="[object Object]",rS=Function.prototype,iS=Object.prototype,oS=rS.toString,aS=iS.hasOwnProperty,uS=oS.call(Object);var sS={};sS["[object Float32Array]"]=sS["[object Float64Array]"]=sS["[object Int8Array]"]=sS["[object Int16Array]"]=sS["[object Int32Array]"]=sS["[object Uint8Array]"]=sS["[object Uint8ClampedArray]"]=sS["[object Uint16Array]"]=sS["[object Uint32Array]"]=!0,sS["[object Arguments]"]=sS["[object Array]"]=sS["[object ArrayBuffer]"]=sS["[object Boolean]"]=sS["[object DataView]"]=sS["[object Date]"]=sS["[object Error]"]=sS["[object Function]"]=sS["[object Map]"]=sS["[object Number]"]=sS["[object Object]"]=sS["[object RegExp]"]=sS["[object Set]"]=sS["[object String]"]=sS["[object WeakMap]"]=!1;var cS,lS="object"==typeof exports&&exports&&!exports.nodeType&&exports,fS=lS&&"object"==typeof module&&module&&!module.nodeType&&module,hS=fS&&fS.exports===lS&&wb.process,dS=function(){try{var t=fS&&fS.require&&fS.require("util").types;return t||hS&&hS.binding&&hS.binding("util")}catch(t){}}(),pS=dS&&dS.isTypedArray,vS=pS?(cS=pS,function(t){return cS(t)}):function(t){return Yk(t)&&Zk(t.length)&&!!sS[Pb(t)]};function yS(t,e){if(("constructor"!==e||"function"!=typeof t[e])&&"__proto__"!=e)return t[e]}var mS=Object.prototype.hasOwnProperty;function gS(t,e,n){var r=t[e];mS.call(t,e)&&tk(r,n)&&(void 0!==n||e in t)||_k(t,e,n)}var wS=9007199254740991,bS=/^(?:0|[1-9]\d*)$/;function xS(t,e){var n=typeof t;return!!(e=null==e?wS:e)&&("number"==n||"symbol"!=n&&bS.test(t))&&t>-1&&t%1==0&&t0){if(++e>=800)return arguments[0]}else e=0;return t.apply(void 0,arguments)}}(AS),RS=TS;function IS(t,e){return RS(function(t,e,n){return e=PS(void 0===e?t.length-1:e,0),function(){for(var r=arguments,i=-1,o=PS(r.length-e,0),a=Array(o);++i1?e[r-1]:void 0,o=r>2?e[2]:void 0;for(i=NS.length>3&&"function"==typeof i?(r--,i):void 0,o&&function(t,e,n){if(!Lb(n))return!1;var r=typeof e;return!!("number"==r?Jk(n)&&xS(e,n.length):"string"==r&&e in n)&&tk(n[e],t)}(e[0],e[1],o)&&(i=r<3?void 0:i,r=1),t=Object(t);++nu))return!1;var c=o.get(t),l=o.get(e);if(c&&l)return c==e&&l==t;var f=-1,h=!0,d=n&US?new zS:void 0;for(o.set(t,e),o.set(e,t);++f0&&void 0!==arguments[0]?arguments[0]:d_;en(this,t),this.preProcessors=e,this.options={itemSelector:"#cal-heatmap",range:12,domain:{type:"hour",gutter:4,padding:[0,0,0,0],dynamicDimension:!0,sort:"asc",label:{text:void 0,position:"bottom",textAlign:"middle",offset:{x:0,y:0},rotate:null,width:100,height:25}},subDomain:{type:"minute",width:10,height:10,gutter:2,radius:0,label:null,color:void 0,sort:"asc"},date:{start:new Date,min:void 0,max:void 0,highlight:[],locale:"en",timezone:void 0},verticalOrientation:!1,data:{source:"",type:"json",requestInit:{},x:"",y:"",groupY:"sum",defaultValue:null},scale:void 0,animationDuration:200,theme:"light",x:{domainHorizontalLabelWidth:0,domainVerticalLabelHeight:0}}}return rn(t,[{key:"set",value:function(t,e){return!(!s_(this.options,t)||Hj(c_(this.options,t),e))&&(l_(this.options,t,s_(this.preProcessors,t)?c_(this.preProcessors,t)(e):e),!0)}},{key:"init",value:function(t){var e=this;this.options=Object.assign({},FS(this.options,t,(function(t,e){return Array.isArray(e)?e:void 0})));var n=this.options;Object.keys(this.preProcessors).forEach((function(t){l_(n,t,c_(e.preProcessors,t)(c_(n,t)))})),void 0===n.scale&&this.initScale(),n.x.domainVerticalLabelHeight=n.domain.label.height,"top"===n.domain.label.position||"bottom"===n.domain.label.position?n.x.domainHorizontalLabelWidth=0:(n.x.domainVerticalLabelHeight=0,n.x.domainHorizontalLabelWidth=n.domain.label.width),null!==n.domain.label.text&&""!==n.domain.label.text||(n.x.domainVerticalLabelHeight=0,n.x.domainHorizontalLabelWidth=0)}},{key:"initScale",value:function(){this.options.scale={color:{scheme:"YlOrBr",type:"quantize",domain:Om}}}}]),t}(),v_=Rr,y_=jn,m_=dn.RegExp,g_=y_((function(){var t=m_("a","y");return t.lastIndex=2,null!==t.exec("abcd")})),w_=g_||y_((function(){return!m_("a","y").sticky})),b_=g_||y_((function(){var t=m_("^r","gy");return t.lastIndex=2,null!==t.exec("str")})),x_={BROKEN_CARET:b_,MISSED_STICKY:w_,UNSUPPORTED_Y:g_},O_=jn,k_=dn.RegExp,S_=O_((function(){var t=k_(".","s");return!(t.dotAll&&t.test("\n")&&"s"===t.flags)})),j_=jn,__=dn.RegExp,M_=j_((function(){var t=__("(?b)","g");return"b"!==t.exec("b").groups.a||"bc"!=="b".replace(t,"$c")})),D_=Wr,$_=Pn,E_=ip,P_=function(){var t=v_(this),e="";return t.hasIndices&&(e+="d"),t.global&&(e+="g"),t.ignoreCase&&(e+="i"),t.multiline&&(e+="m"),t.dotAll&&(e+="s"),t.unicode&&(e+="u"),t.unicodeSets&&(e+="v"),t.sticky&&(e+="y"),e},L_=x_,A_=Ih,C_=po.get,T_=S_,R_=M_,I_=Sn("native-string-replace",String.prototype.replace),N_=RegExp.prototype.exec,W_=N_,F_=$_("".charAt),z_=$_("".indexOf),H_=$_("".replace),Y_=$_("".slice),U_=(h_=/b*/g,D_(N_,f_=/a/,"a"),D_(N_,h_,"a"),0!==f_.lastIndex||0!==h_.lastIndex),B_=L_.BROKEN_CARET,G_=void 0!==/()??/.exec("")[1];(U_||G_||B_||T_||R_)&&(W_=function(t){var e,n,r,i,o,a,u,s=this,c=C_(s),l=E_(t),f=c.raw;if(f)return f.lastIndex=s.lastIndex,e=D_(W_,f,l),s.lastIndex=f.lastIndex,e;var h=c.groups,d=B_&&s.sticky,p=D_(P_,s),v=s.source,y=0,m=l;if(d&&(p=H_(p,"y",""),-1===z_(p,"g")&&(p+="g"),m=Y_(l,s.lastIndex),s.lastIndex>0&&(!s.multiline||s.multiline&&"\n"!==F_(l,s.lastIndex-1))&&(v="(?: "+v+")",m=" "+m,y++),n=new RegExp("^(?:"+v+")",p)),G_&&(n=new RegExp("^"+v+"$(?!\\s)",p)),U_&&(r=s.lastIndex),i=D_(N_,d?n:s,m),d?i?(i.input=Y_(i.input,y),i[0]=Y_(i[0],y),i.index=s.lastIndex,s.lastIndex+=i[0].length):s.lastIndex=0:U_&&i&&(s.lastIndex=s.global?i.index+i[0].length:r),G_&&i&&i.length>1&&D_(I_,i[0],n,(function(){for(o=1;o]*>)/g,hM=/\$([$&'`]|\d{1,2})/g,dM=Wr,pM=Rr,vM=br,yM=zo,mM=V_,gM=TypeError,wM=xs,bM=Wr,xM=Pn,OM=function(t,e,n,r){var i=tM(t),o=!X_((function(){var e={};return e[i]=function(){return 7},7!==""[t](e)})),a=o&&!X_((function(){var e=!1,n=/a/;return"split"===t&&((n={}).constructor={},n.constructor[nM]=function(){return n},n.flags="",n[i]=/./[i]),n.exec=function(){return e=!0,null},n[i](""),!e}));if(!o||!a||n){var u=Z_(/./[i]),s=e(i,""[t],(function(t,e,n,r,i){var a=Z_(t),s=e.exec;return s===Q_||s===rM.exec?o&&!i?{done:!0,value:u(e,n,r)}:{done:!0,value:a(n,e,r)}:{done:!1}}));J_(String.prototype,t,s[0]),J_(rM,i,s[1])}r&&eM(rM[i],"sham",!0)},kM=jn,SM=Rr,jM=br,_M=Ln,MM=ka,DM=Ea,$M=ip,EM=Tn,PM=function(t,e,n){return e+(n?iM(t,e).length:1)},LM=ri,AM=function(t,e,n,r,i,o){var a=n+t.length,u=r.length,s=hM;return void 0!==i&&(i=aM(i),s=fM),cM(o,s,(function(o,s){var c;switch(sM(s,0)){case"$":return"$";case"&":return t;case"`":return lM(e,0,n);case"'":return lM(e,a);case"<":c=i[lM(s,1,-1)];break;default:var l=+s;if(0===l)return o;if(l>u){var f=uM(l/10);return 0===f?o:f<=u?void 0===r[f-1]?sM(s,1):r[f-1]+sM(s,1):o}c=r[l-1]}return void 0===c?"":c}))},CM=function(t,e){var n=t.exec;if(vM(n)){var r=dM(n,t,e);return null!==r&&pM(r),r}if("RegExp"===yM(t))return dM(mM,t,e);throw new gM("RegExp#exec called on incompatible receiver")},TM=pr("replace"),RM=Math.max,IM=Math.min,NM=xM([].concat),WM=xM([].push),FM=xM("".indexOf),zM=xM("".slice),HM="$0"==="a".replace(/./,"$0"),YM=!!/./[TM]&&""===/./[TM]("a","$0"),UM=!kM((function(){var t=/./;return t.exec=function(){var t=[];return t.groups={a:"7"},t},"7"!=="".replace(t,"$")}));OM("replace",(function(t,e,n){var r=YM?"$":"$0";return[function(t,n){var r=EM(this),i=_M(t)?void 0:LM(t,TM);return i?bM(i,t,r,n):bM(e,$M(r),t,n)},function(t,i){var o=SM(this),a=$M(t);if("string"==typeof i&&-1===FM(i,r)&&-1===FM(i,"$<")){var u=n(e,o,a,i);if(u.done)return u.value}var s=jM(i);s||(i=$M(i));var c,l=o.global;l&&(c=o.unicode,o.lastIndex=0);for(var f,h=[];null!==(f=CM(o,a))&&(WM(h,f),l);){""===$M(f[0])&&(o.lastIndex=PM(a,DM(o.lastIndex),c))}for(var d,p="",v=0,y=0;y=v&&(p+=zM(a,v,w)+m,v=w+g.length)}return p+zM(a,v)}]}),!UM||!HM||YM);var BM=function(){function t(e){en(this,t),q_.add(this),this.calendar=e}return rn(t,[{key:"getDatas",value:function(t,e,n){return fv(this,void 0,void 0,Xe().mark((function r(){var i;return Xe().wrap((function(r){for(;;)switch(r.prev=r.next){case 0:if(!("string"==typeof t&&t.length>0)){r.next=2;break}return r.abrupt("return",hv(this,q_,"m",K_).call(this,t,e,n));case 2:return i=[],Array.isArray(t)&&(i=t),r.abrupt("return",new Promise((function(t){t(i)})));case 5:case"end":return r.stop()}}),r,this)})))}},{key:"parseURI",value:function(t,e,n){var r=this,i=t.replace(/\{\{start=(.*?)\}\}/g,(function(t,n){return r.calendar.dateHelper.date(e).format(n)}));return i=i.replace(/\{\{end=(.*?)\}\}/g,(function(t,e){return r.calendar.dateHelper.date(n).format(e)}))}}]),t}();q_=new WeakSet,K_=function(t,e,n){var r=this.calendar.options.options.data,i=r.type,o=r.requestInit,a=this.parseURI(t,e,n);switch(i){case"json":return Qe(a,o);case"csv":return Je(a,o);case"tsv":return Ze("\t",a,o);case"txt":return Ke(a,o);default:return new Promise((function(t){t([])}))}};var GM=Or,VM=Ti.EXISTS,qM=Pn,KM=Iu,ZM=Function.prototype,JM=qM(ZM.toString),QM=/function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/,XM=qM(QM.exec);GM&&!VM&&KM(ZM,"name",{configurable:!0,get:function(){try{return XM(QM,JM(this))[1]}catch(t){return""}}});var tD={exports:{}};tD.exports=function(){var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",o="minute",a="hour",u="day",s="week",c="month",l="quarter",f="year",h="date",d="Invalid Date",p=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,v=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,y={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function(t){var e=["th","st","nd","rd"],n=t%100;return"["+t+(e[(n-20)%10]||e[n]||e[0])+"]"}},m=function(t,e,n){var r=String(t);return!r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},g={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()1)return t(a[0])}else{var u=e.name;b[u]=e,i=u}return!r&&i&&(w=i),i||!r&&w},S=function(t,e){if(O(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},j=g;j.l=k,j.i=O,j.w=function(t,e){return S(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function y(t){this.$L=k(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[x]=!0}var m=y.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(j.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match(p);if(r){var i=r[2]-1||0,o=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,o)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,o)}}return new Date(e)}(t),this.init()},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},m.$utils=function(){return j},m.isValid=function(){return!(this.$d.toString()===d)},m.isSame=function(t,e){var n=S(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return S(t)25){var r=n(this).startOf(nD).add(1,nD).date(e),i=n(this).endOf(eD);if(r.isBefore(i))return 1}var o=n(this).startOf(nD).date(e).startOf(eD).subtract(1,"millisecond"),a=this.diff(o,eD,!0);return a<0?n(this).startOf("week").week():Math.ceil(a)},r.weeks=function(t){return void 0===t&&(t=null),this.week(t)}})),aD={exports:{}};aD.exports=function(t,e,n){e.prototype.dayOfYear=function(t){var e=Math.round((n(this).startOf("day")-n(this).startOf("year"))/864e5)+1;return null==t?e:this.add(t-e,"day")}};var uD=fn(aD.exports),sD={exports:{}};sD.exports=function(t,e){e.prototype.weekday=function(t){var e=this.$locale().weekStart||0,n=this.$W,r=(n0&&(e=e[0]),n=(e=e.filter((function(t){return t})))[0];for(var r=1;r4&&(a+=7),o.add(a,t));return u.diff(s,"week")+1},o.isoWeekday=function(t){return this.$utils().u(t)?this.day()||7:this.day(this.day()%7?t:t-7)};var a=o.startOf;o.startOf=function(t,e){var n=this.$utils(),r=!!n.u(e)||e;return"isoweek"===n.p(t)?r?this.date(this.date()-(this.isoWeekday()-1)).startOf("day"):this.date(this.date()-1-(this.isoWeekday()-1)+7).endOf("day"):a.bind(this)(t,e)}}}();var vD=fn(pD.exports),yD={exports:{}};yD.exports=function(t,e){e.prototype.isLeapYear=function(){return this.$y%4==0&&this.$y%100!=0||this.$y%400==0}};var mD=fn(yD.exports),gD={exports:{}};gD.exports=function(t,e){var n=e.prototype,r=n.format;n.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return r.bind(this)(t);var i=this.$utils(),o=(t||"YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g,(function(t){switch(t){case"Q":return Math.ceil((e.$M+1)/3);case"Do":return n.ordinal(e.$D);case"gggg":return e.weekYear();case"GGGG":return e.isoWeekYear();case"wo":return n.ordinal(e.week(),"W");case"w":case"ww":return i.s(e.week(),"w"===t?1:2,"0");case"W":case"WW":return i.s(e.isoWeek(),"W"===t?1:2,"0");case"k":case"kk":return i.s(String(0===e.$H?24:e.$H),"k"===t?1:2,"0");case"X":return Math.floor(e.$d.getTime()/1e3);case"x":return e.$d.getTime();case"z":return"["+e.offsetName()+"]";case"zzz":return"["+e.offsetName("long")+"]";default:return t}}));return r.bind(this)(o)}};var wD=fn(gD.exports),bD={exports:{}};bD.exports=function(){var t="minute",e=/[+-]\d\d(?::?\d\d)?/g,n=/([+-]|\d\d)/g;return function(r,i,o){var a=i.prototype;o.utc=function(t){return new i({date:t,utc:!0,args:arguments})},a.utc=function(e){var n=o(this.toDate(),{locale:this.$L,utc:!0});return e?n.add(this.utcOffset(),t):n},a.local=function(){return o(this.toDate(),{locale:this.$L,utc:!1})};var u=a.parse;a.parse=function(t){t.utc&&(this.$u=!0),this.$utils().u(t.$offset)||(this.$offset=t.$offset),u.call(this,t)};var s=a.init;a.init=function(){if(this.$u){var t=this.$d;this.$y=t.getUTCFullYear(),this.$M=t.getUTCMonth(),this.$D=t.getUTCDate(),this.$W=t.getUTCDay(),this.$H=t.getUTCHours(),this.$m=t.getUTCMinutes(),this.$s=t.getUTCSeconds(),this.$ms=t.getUTCMilliseconds()}else s.call(this)};var c=a.utcOffset;a.utcOffset=function(r,i){var o=this.$utils().u;if(o(r))return this.$u?0:o(this.$offset)?c.call(this):this.$offset;if("string"==typeof r&&(r=function(t){void 0===t&&(t="");var r=t.match(e);if(!r)return null;var i=(""+r[0]).match(n)||["-",0,0],o=i[0],a=60*+i[1]+ +i[2];return 0===a?0:"+"===o?a:-a}(r),null===r))return this;var a=Math.abs(r)<=16?60*r:r,u=this;if(i)return u.$offset=a,u.$u=0===r,u;if(0!==r){var s=this.$u?this.toDate().getTimezoneOffset():-1*this.utcOffset();(u=this.local().add(a+s,t)).$offset=a,u.$x.$localOffset=s}else u=this.utc();return u};var l=a.format;a.format=function(t){var e=t||(this.$u?"YYYY-MM-DDTHH:mm:ss[Z]":"");return l.call(this,e)},a.valueOf=function(){var t=this.$utils().u(this.$offset)?0:this.$offset+(this.$x.$localOffset||this.$d.getTimezoneOffset());return this.$d.valueOf()-6e4*t},a.isUTC=function(){return!!this.$u},a.toISOString=function(){return this.toDate().toISOString()},a.toString=function(){return this.toDate().toUTCString()};var f=a.toDate;a.toDate=function(t){return"s"===t&&this.$offset?o(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate():f.call(this)};var h=a.diff;a.diff=function(t,e,n){if(t&&this.$u===t.$u)return h.call(this,t,e,n);var r=this.local(),i=o(t).local();return h.call(r,i,e,n)}}}();var xD=fn(bD.exports),OD={exports:{}};OD.exports=function(){var t={year:0,month:1,day:2,hour:3,minute:4,second:5},e={};return function(n,r,i){var o,a=function(t,n,r){void 0===r&&(r={});var i=new Date(t),o=function(t,n){void 0===n&&(n={});var r=n.timeZoneName||"short",i=t+"|"+r,o=e[i];return o||(o=new Intl.DateTimeFormat("en-US",{hour12:!1,timeZone:t,year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",second:"2-digit",timeZoneName:r}),e[i]=o),o}(n,r);return o.formatToParts(i)},u=function(e,n){for(var r=a(e,n),o=[],u=0;u=0&&(o[f]=parseInt(l,10))}var h=o[3],d=24===h?0:h,p=o[0]+"-"+o[1]+"-"+o[2]+" "+d+":"+o[4]+":"+o[5]+":000",v=+e;return(i.utc(p).valueOf()-(v-=v%1e3))/6e4},s=r.prototype;s.tz=function(t,e){void 0===t&&(t=o);var n=this.utcOffset(),r=this.toDate(),a=r.toLocaleString("en-US",{timeZone:t}),u=Math.round((r-new Date(a))/1e3/60),s=i(a,{locale:this.$L}).$set("millisecond",this.$ms).utcOffset(15*-Math.round(r.getTimezoneOffset()/15)-u,!0);if(e){var c=s.utcOffset();s=s.add(n-c,"minute")}return s.$x.$timezone=t,s},s.offsetName=function(t){var e=this.$x.$timezone||i.tz.guess(),n=a(this.valueOf(),e,{timeZoneName:t}).find((function(t){return"timezonename"===t.type.toLowerCase()}));return n&&n.value};var c=s.startOf;s.startOf=function(t,e){if(!this.$x||!this.$x.$timezone)return c.call(this,t,e);var n=i(this.format("YYYY-MM-DD HH:mm:ss:SSS"),{locale:this.$L});return c.call(n,t,e).tz(this.$x.$timezone,!0)},i.tz=function(t,e,n){var r=n&&e,a=n||e||o,s=u(+i(),a);if("string"!=typeof t)return i(t).tz(a);var c=function(t,e,n){var r=t-60*e*1e3,i=u(r,n);if(e===i)return[r,e];var o=u(r-=60*(i-e)*1e3,n);return i===o?[r,i]:[t-60*Math.min(i,o)*1e3,Math.max(i,o)]}(i.utc(t,r).valueOf(),s,a),l=c[0],f=c[1],h=i(l).utcOffset(f);return h.$x.$timezone=a,h},i.tz.guess=function(){return Intl.DateTimeFormat().resolvedOptions().timeZone},i.tz.setDefault=function(t){o=t}}}();var kD=fn(OD.exports),SD={exports:{}};SD.exports=function(t,e,n){var r=e.prototype,i=function(t){return t&&(t.indexOf?t:t.s)},o=function(t,e,n,r,o){var a=t.name?t:t.$locale(),u=i(a[e]),s=i(a[n]),c=u||s.map((function(t){return t.slice(0,r)}));if(!o)return c;var l=a.weekStart;return c.map((function(t,e){return c[(e+(l||0))%7]}))},a=function(){return n.Ls[n.locale()]},u=function(t,e){return t.formats[e]||function(t){return t.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(t,e,n){return e||n.slice(1)}))}(t.formats[e.toUpperCase()])},s=function(){var t=this;return{months:function(e){return e?e.format("MMMM"):o(t,"months")},monthsShort:function(e){return e?e.format("MMM"):o(t,"monthsShort","months",3)},firstDayOfWeek:function(){return t.$locale().weekStart||0},weekdays:function(e){return e?e.format("dddd"):o(t,"weekdays")},weekdaysMin:function(e){return e?e.format("dd"):o(t,"weekdaysMin","weekdays",2)},weekdaysShort:function(e){return e?e.format("ddd"):o(t,"weekdaysShort","weekdays",3)},longDateFormat:function(e){return u(t.$locale(),e)},meridiem:this.$locale().meridiem,ordinal:this.$locale().ordinal}};r.localeData=function(){return s.bind(this)()},n.localeData=function(){var t=a();return{firstDayOfWeek:function(){return t.weekStart||0},weekdays:function(){return n.weekdays()},weekdaysShort:function(){return n.weekdaysShort()},weekdaysMin:function(){return n.weekdaysMin()},months:function(){return n.months()},monthsShort:function(){return n.monthsShort()},longDateFormat:function(e){return u(t,e)},meridiem:t.meridiem,ordinal:t.ordinal}},n.months=function(){return o(a(),"months")},n.monthsShort=function(){return o(a(),"monthsShort","months",3)},n.weekdays=function(t){return o(a(),"weekdays",null,null,t)},n.weekdaysShort=function(t){return o(a(),"weekdaysShort","weekdays",3,t)},n.weekdaysMin=function(t){return o(a(),"weekdaysMin","weekdays",2,t)}};var jD=fn(SD.exports),_D={exports:{}};_D.exports=function(){var t={LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"};return function(e,n,r){var i=n.prototype,o=i.format;r.en.formats=t,i.format=function(e){void 0===e&&(e="YYYY-MM-DDTHH:mm:ssZ");var n=this.$locale().formats,r=function(e,n){return e.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g,(function(e,r,i){var o=i&&i.toUpperCase();return r||n[i]||t[i]||n[o].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(t,e,n){return e||n.slice(1)}))}))}(e,void 0===n?{}:n);return o.call(this,r)}}}();var MD=fn(_D.exports),DD={exports:{}};DD.exports=function(t,e,n){n.updateLocale=function(t,e){var r=n.Ls[t];if(r)return(e?Object.keys(e):[]).forEach((function(t){r[t]=e[t]})),r}};var $D=fn(DD.exports);rD.extend(oD),rD.extend(dD),rD.extend(vD),rD.extend(mD),rD.extend(uD),rD.extend(cD),rD.extend(fD),rD.extend(wD),rD.extend(xD),rD.extend(kD),rD.extend(jD),rD.extend(MD),rD.extend($D);var ED="en",PD=function(){function t(){var e;en(this,t),this.locale=ED,this.timezone=rD.tz.guess(),"object"===("undefined"==typeof window?"undefined":tn(window))&&((e=window).dayjs||(e.dayjs=rD))}return rn(t,[{key:"setup",value:function(t){var e=t.options;return fv(this,void 0,void 0,Xe().mark((function t(){var n,r;return Xe().wrap((function(t){for(;;)switch(t.prev=t.next){case 0:if(this.timezone=e.date.timezone||rD.tz.guess(),"string"!=typeof(n=e.date.locale)||n===ED){t.next=17;break}if("object"!==("undefined"==typeof window?"undefined":tn(window))){t.next=12;break}if(t.t0=window["dayjs_locale_".concat(n)],t.t0){t.next=9;break}return t.next=8,this.loadBrowserLocale(n);case 8:t.t0=t.sent;case 9:r=t.t0,t.next=15;break;case 12:return t.next=14,this.loadNodeLocale(n);case 14:r=t.sent;case 15:rD.locale(n),this.locale=r;case 17:"object"===tn(n)&&(n.hasOwnProperty("name")?(rD.locale(n.name,n),this.locale=n):this.locale=rD.updateLocale(ED,n));case 18:case"end":return t.stop()}}),t,this)})))}},{key:"extend",value:function(t){return rD.extend(t)}},{key:"getMonthWeekNumber",value:function(t){var e=this.date(t),n=e.startOf("day"),r=e.startOf("month").endOf("week");return n<=r?1:Math.ceil(n.diff(r,"weeks",!0))+1}},{key:"getWeeksCountInMonth",value:function(t){var e=this.date(t);return this.getLastWeekOfMonth(e).diff(this.getFirstWeekOfMonth(e),"week")+1}},{key:"getFirstWeekOfMonth",value:function(t){var e=this.date(t).startOf("month"),n=e.startOf("week");return e.weekday()>4&&(n=n.add(1,"week")),n}},{key:"getLastWeekOfMonth",value:function(t){var e=this.date(t).endOf("month"),n=e.endOf("week");return e.weekday()<4&&(n=n.subtract(1,"week")),n}},{key:"date",value:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:new Date;return rD.isDayjs(t)?t:rD(t).tz(this.timezone).utcOffset(0).locale(this.locale)}},{key:"format",value:function(t,e){if("function"==typeof e){for(var n=arguments.length,r=new Array(n>2?n-2:0),i=2;i3&&void 0!==arguments[3])||arguments[3],o=this.date(e);r="number"==typeof n?o.add(n,t):rD.isDayjs(n)?n:this.date(n),o=o.startOf(t),r=r.startOf(t);var a=rD.min(o,r);r=rD.max(o,r);var u=[];i||(r=r.add(1,"second"));do{u.push(+a),a=a.add(1,t)}while(a1?arguments[1]:void 0)}});var ND=["json","csv","tsv","txt"];function WD(t,e){var n=e.domain,r=e.subDomain,i=e.data,o=n.type,a=r.type;if(!t.has(o))throw new Error("'".concat(o,"' is not a valid domain type'"));if(!t.has(a))throw new Error("'".concat(a,"' is not a valid subDomain type'"));if(i.type&&!ND.includes(i.type))throw new Error("The data type '".concat(i.type,"' is not valid data type"));if(!(t.get(a).allowedDomainType||[]).includes(o))throw new Error("The subDomain.type '".concat(a,"' can not be used together ")+"with the domain type ".concat(o));return!0}qy("Set",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),ag);var FD=function(){function t(e){en(this,t),this.calendar=e,this.settings=new Map,this.plugins=new Map,this.pendingPaint=new Set}return rn(t,[{key:"add",value:function(t){var e=this;t.forEach((function(t){var n,r,i=on(t,2),o=i[0],a=i[1],u=function(t,e){return"".concat((new t).name).concat((null==e?void 0:e.key)||"")}(o,a);e.plugins.get(u)&&e.settings.get(u)&&Hj(e.settings.get(u).options,a)||(e.settings.set(u,{options:a,dirty:!0}),e.plugins.has(u)||e.plugins.set(u,(n=o,r=e.calendar,new n(r))),e.pendingPaint.add(e.plugins.get(u)))}))}},{key:"setupAll",value:function(){var t=this;this.plugins.forEach((function(e,n){var r=t.settings.get(n);void 0!==r&&r.dirty&&(e.setup(r.options),r.dirty=!1,t.settings.set(n,r))}))}},{key:"paintAll",value:function(){return Array.from(this.pendingPaint.values()).map((function(t){return t.paint()}))}},{key:"destroyAll",value:function(){return this.allPlugins().map((function(t){return t.destroy()}))}},{key:"getFromPosition",value:function(t){return this.allPlugins().filter((function(e){var n;return(null===(n=e.options)||void 0===n?void 0:n.position)===t}))}},{key:"getHeightFromPosition",value:function(t){return this.getFromPosition(t).map((function(t){return t.options.dimensions.height})).reduce((function(t,e){return t+e}),0)}},{key:"getWidthFromPosition",value:function(t){return this.getFromPosition(t).map((function(t){return t.options.dimensions.width})).reduce((function(t,e){return t+e}),0)}},{key:"allPlugins",value:function(){return Array.from(this.plugins.values())}}]),t}(),zD=[function(t){return{name:"minute",allowedDomainType:["day","hour"],rowsCount:function(){return 10},columnsCount:function(){return 6},mapping:function(e,n){return t.intervals("minute",e,t.date(n)).map((function(t,e){return{t:t,x:Math.floor(e/10),y:e%10}}))},extractUnit:function(e){return t.date(e).startOf("minute").valueOf()}}},function(t,e){var n=e.domain;return{name:"hour",allowedDomainType:["month","week","day"],rowsCount:function(){return 6},columnsCount:function(e){switch(n.type){case"week":return 28;case"month":return 4*(n.dynamicDimension?t.date(e).daysInMonth():31);default:return 4}},mapping:function(e,r){return t.intervals("hour",e,t.date(r)).map((function(e){var r=t.date(e),i=r.hour(),o=r.date(),a=Math.floor(i/6);return"month"===n.type&&(a+=4*(o-1)),"week"===n.type&&(a+=4*+r.format("d")),{t:e,x:a,y:Math.floor(i%6)}}))},extractUnit:function(e){return t.date(e).startOf("hour").valueOf()}}},function(t,e){var n=e.domain,r=e.verticalOrientation;return{name:"day",allowedDomainType:["year","month","week"],rowsCount:function(){return"week"===n.type?1:7},columnsCount:function(e){switch(n.type){case"month":return Math.ceil(n.dynamicDimension&&!r?t.getMonthWeekNumber(t.date(e).endOf("month")):6);case"year":return Math.ceil(n.dynamicDimension?t.date(e).endOf("year").dayOfYear()/7:54);default:return 7}},mapping:function(e,r){var i=0,o=-1;return t.intervals("day",e,t.date(r)).map((function(e){var r=t.date(e);switch(n.type){case"month":o=t.getMonthWeekNumber(e)-1;break;case"year":i!==r.week()&&(i=r.week(),o+=1);break;case"week":o=r.weekday()}return{t:e,x:o,y:"week"===n.type?0:r.weekday()}}))},extractUnit:function(e){return t.date(e).startOf("day").valueOf()}}},function(t,e){var n=e.domain,r=e.verticalOrientation;return{name:"xDay",allowedDomainType:["year","month","week"],rowsCount:function(e){switch(n.type){case"month":return Math.ceil(n.dynamicDimension&&!r?t.getMonthWeekNumber(t.date(e).endOf("month")):6);case"year":return Math.ceil(n.dynamicDimension?t.date(e).endOf("year").dayOfYear()/7:54);default:return 7}},columnsCount:function(){return"week"===n.type?1:7},mapping:function(e,r){return t.intervals("day",e,t.date(r)).map((function(e){var r=t.date(e),i=r.endOf("year").week(),o=0;switch(n.type){case"month":o=t.getMonthWeekNumber(e)-1;break;case"year":1===i&&r.week()===i&&(o=r.subtract(1,"week").week()+1),o=r.week()-1;break;case"week":o=r.weekday()}return{t:e,y:o,x:"week"===n.type?0:r.weekday()}}))},extractUnit:function(e){return t.date(e).startOf("day").valueOf()}}},function(t){return{name:"ghDay",allowedDomainType:["month"],rowsCount:function(){return 7},columnsCount:function(e){return t.getWeeksCountInMonth(e)},mapping:function(e,n){var r=t.getFirstWeekOfMonth(e),i=t.getFirstWeekOfMonth(n),o=-1,a=r.weekday();return t.intervals("day",r,i).map((function(e){var n=t.date(e).weekday();return n===a&&(o+=1),{t:e,x:o,y:n}}))},extractUnit:function(e){return t.date(e).startOf("day").valueOf()}}},function(t,e){var n=e.domain;return{name:"week",allowedDomainType:["year","month"],rowsCount:function(){return 1},columnsCount:function(e){switch(n.type){case"year":return n.dynamicDimension?t.date(e).endOf("year").isoWeeksInYear():53;case"month":return n.dynamicDimension?t.getWeeksCountInMonth(e):5;default:return 1}},mapping:function(e,n){var r=t.getFirstWeekOfMonth(e),i=t.getFirstWeekOfMonth(n);return t.intervals("week",r,i).map((function(t,e){return{t:t,x:e,y:0}}))},extractUnit:function(e){return t.date(e).startOf("week").valueOf()}}},function(t){return{name:"month",allowedDomainType:["year"],rowsCount:function(){return 1},columnsCount:function(){return 12},mapping:function(e,n){return t.intervals("month",e,t.date(n)).map((function(e){return{t:e,x:t.date(e).month(),y:0}}))},extractUnit:function(e){return t.date(e).startOf("month").valueOf()}}},function(t){return{name:"year",allowedDomainType:[],rowsCount:function(){return 1},columnsCount:function(){return 1},mapping:function(e,n){return t.intervals("year",e,t.date(n)).map((function(t,e){return{t:t,x:e,y:0}}))},extractUnit:function(e){return t.date(e).startOf("year").valueOf()}}}],HD=function(){function t(e,n){en(this,t),this.settings=new Map,this.dateHelper=e,this.options=n,this.initiated=!1}return rn(t,[{key:"get",value:function(t){return this.settings.get(t)}},{key:"has",value:function(t){return this.settings.has(t)}},{key:"init",value:function(){this.initiated||(this.initiated=!0,this.add(zD))}},{key:"add",value:function(t){var e=this;this.init();var n=[];yv(t).forEach((function(t){var r=t(e.dateHelper,e.options.options);e.settings.set(r.name,r),r.hasOwnProperty("parent")&&n.push(r.name)})),n.forEach((function(t){var n=e.settings.get(e.settings.get(t).parent);n&&e.settings.set(t,Object.assign(Object.assign({},n),e.settings.get(t)))}))}}]),t}(),YD=function(){function t(){en(this,t),this.options=new p_,this.dateHelper=new PD,this.templateCollection=new HD(this.dateHelper,this.options),this.dataFetcher=new BM(this),this.navigator=new km(this),this.populator=new XO(this),this.calendarPainter=new gb(this),this.eventEmitter=new pv,this.pluginManager=new FD(this)}return rn(t,[{key:"createDomainCollection",value:function(t,e){var n=!(arguments.length>2&&void 0!==arguments[2])||arguments[2];return new Tw(this.dateHelper,this.options.options.domain.type,t,e,n)}},{key:"paint",value:function(t,e){return fv(this,void 0,void 0,Xe().mark((function n(){return Xe().wrap((function(n){for(;;)switch(n.prev=n.next){case 0:return this.options.init(t),n.next=3,this.dateHelper.setup(this.options);case 3:this.templateCollection.init(),n.prev=4,WD(this.templateCollection,this.options.options),n.next=11;break;case 8:return n.prev=8,n.t0=n.catch(4),n.abrupt("return",Promise.reject(n.t0));case 11:return e&&this.pluginManager.add(yv(e)),this.calendarPainter.setup(),this.domainCollection=new Tw(this.dateHelper),this.navigator.loadNewDomains(this.createDomainCollection(this.options.options.date.start,this.options.options.range)),n.abrupt("return",Promise.allSettled([this.calendarPainter.paint(),this.fill()]));case 16:case"end":return n.stop()}}),n,this,[[4,8]])})))}},{key:"addTemplates",value:function(t){this.templateCollection.add(t)}},{key:"next",value:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:1,e=this.navigator.loadNewDomains(this.createDomainCollection(this.domainCollection.max,t+1).slice(t),vm.SCROLL_FORWARD);return Promise.allSettled([this.calendarPainter.paint(e),this.fill()])}},{key:"previous",value:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:1,e=this.navigator.loadNewDomains(this.createDomainCollection(this.domainCollection.min,-t),vm.SCROLL_BACKWARD);return Promise.allSettled([this.calendarPainter.paint(e),this.fill()])}},{key:"jumpTo",value:function(t){var e=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return Promise.allSettled([this.calendarPainter.paint(this.navigator.jumpTo(t,e)),this.fill()])}},{key:"fill",value:function(){var t=this,e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:this.options.options.data.source,n=this.options.options,r=this.templateCollection,i=this.dateHelper.intervals(n.domain.type,this.domainCollection.max,2)[1],o=this.dataFetcher.getDatas(e,this.domainCollection.min,i);return new Promise((function(e,i){o.then((function(i){t.domainCollection.fill(i,n.data,r.get(n.subDomain.type).extractUnit),t.populator.populate(),e(null)}),(function(t){i(t)}))}))}},{key:"on",value:function(t,e){this.eventEmitter.on(t,e)}},{key:"dimensions",value:function(){return this.calendarPainter.dimensions}},{key:"destroy",value:function(){return this.calendarPainter.destroy()}},{key:"extendDayjs",value:function(t){return this.dateHelper.extend(t)}}]),t}();YD.VERSION="4.2.4";export{YD as default};//# sourceMappingURL=cal-heatmap.min.esm.js.map diff --git a/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.esm.js.map b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.esm.js.map new file mode 100644 index 0000000..03c62e0 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.esm.js.map @@ -0,0 +1 @@ +{"version":3,"file":"cal-heatmap.min.esm.js","sources":["../node_modules/core-js/internals/global.js","../node_modules/core-js/internals/define-global-property.js","../node_modules/core-js/internals/shared-store.js","../node_modules/core-js/internals/shared.js","../node_modules/core-js/internals/engine-v8-version.js","../node_modules/core-js/internals/fails.js","../node_modules/core-js/internals/function-bind-native.js","../node_modules/core-js/internals/function-uncurry-this.js","../node_modules/core-js/internals/is-null-or-undefined.js","../node_modules/core-js/internals/require-object-coercible.js","../node_modules/core-js/internals/to-object.js","../node_modules/core-js/internals/has-own-property.js","../node_modules/core-js/internals/uid.js","../node_modules/core-js/internals/engine-user-agent.js","../node_modules/core-js/internals/symbol-constructor-detection.js","../node_modules/core-js/internals/use-symbol-as-uid.js","../node_modules/core-js/internals/well-known-symbol.js","../node_modules/core-js/internals/to-string-tag-support.js","../node_modules/core-js/internals/document-all.js","../node_modules/core-js/internals/is-callable.js","../node_modules/core-js/internals/descriptors.js","../node_modules/core-js/internals/is-object.js","../node_modules/core-js/internals/document-create-element.js","../node_modules/core-js/internals/ie8-dom-define.js","../node_modules/core-js/internals/v8-prototype-define-bug.js","../node_modules/core-js/internals/an-object.js","../node_modules/core-js/internals/function-call.js","../node_modules/core-js/internals/get-built-in.js","../node_modules/core-js/internals/object-is-prototype-of.js","../node_modules/core-js/internals/is-symbol.js","../node_modules/core-js/internals/try-to-string.js","../node_modules/core-js/internals/a-callable.js","../node_modules/core-js/internals/get-method.js","../node_modules/core-js/internals/ordinary-to-primitive.js","../node_modules/core-js/internals/to-primitive.js","../node_modules/core-js/internals/to-property-key.js","../node_modules/core-js/internals/object-define-property.js","../node_modules/core-js/internals/function-name.js","../node_modules/core-js/internals/inspect-source.js","../node_modules/core-js/internals/internal-state.js","../node_modules/core-js/internals/weak-map-basic-detection.js","../node_modules/core-js/internals/create-property-descriptor.js","../node_modules/core-js/internals/create-non-enumerable-property.js","../node_modules/core-js/internals/shared-key.js","../node_modules/core-js/internals/hidden-keys.js","../node_modules/core-js/internals/make-built-in.js","../node_modules/core-js/internals/define-built-in.js","../node_modules/core-js/internals/classof-raw.js","../node_modules/core-js/internals/classof.js","../node_modules/core-js/internals/object-to-string.js","../node_modules/core-js/modules/es.object.to-string.js","../node_modules/core-js/internals/object-property-is-enumerable.js","../node_modules/core-js/internals/indexed-object.js","../node_modules/core-js/internals/to-indexed-object.js","../node_modules/core-js/internals/object-get-own-property-descriptor.js","../node_modules/core-js/internals/math-trunc.js","../node_modules/core-js/internals/to-integer-or-infinity.js","../node_modules/core-js/internals/to-absolute-index.js","../node_modules/core-js/internals/to-length.js","../node_modules/core-js/internals/length-of-array-like.js","../node_modules/core-js/internals/array-includes.js","../node_modules/core-js/internals/object-keys-internal.js","../node_modules/core-js/internals/enum-bug-keys.js","../node_modules/core-js/internals/object-get-own-property-names.js","../node_modules/core-js/internals/object-get-own-property-symbols.js","../node_modules/core-js/internals/own-keys.js","../node_modules/core-js/internals/copy-constructor-properties.js","../node_modules/core-js/internals/is-forced.js","../node_modules/core-js/internals/export.js","../node_modules/core-js/internals/engine-is-node.js","../node_modules/core-js/internals/function-uncurry-this-accessor.js","../node_modules/core-js/internals/a-possible-prototype.js","../node_modules/core-js/internals/object-set-prototype-of.js","../node_modules/core-js/internals/set-to-string-tag.js","../node_modules/core-js/internals/define-built-in-accessor.js","../node_modules/core-js/internals/set-species.js","../node_modules/core-js/internals/an-instance.js","../node_modules/core-js/internals/is-constructor.js","../node_modules/core-js/internals/task.js","../node_modules/core-js/internals/a-constructor.js","../node_modules/core-js/internals/species-constructor.js","../node_modules/core-js/internals/function-apply.js","../node_modules/core-js/internals/function-uncurry-this-clause.js","../node_modules/core-js/internals/function-bind-context.js","../node_modules/core-js/internals/html.js","../node_modules/core-js/internals/array-slice.js","../node_modules/core-js/internals/validate-arguments-length.js","../node_modules/core-js/internals/engine-is-ios.js","../node_modules/core-js/internals/queue.js","../node_modules/core-js/internals/microtask.js","../node_modules/core-js/internals/engine-is-ios-pebble.js","../node_modules/core-js/internals/engine-is-webos-webkit.js","../node_modules/core-js/internals/perform.js","../node_modules/core-js/internals/promise-native-constructor.js","../node_modules/core-js/internals/engine-is-deno.js","../node_modules/core-js/internals/engine-is-browser.js","../node_modules/core-js/internals/promise-constructor-detection.js","../node_modules/core-js/internals/new-promise-capability.js","../node_modules/core-js/modules/es.promise.constructor.js","../node_modules/core-js/internals/host-report-errors.js","../node_modules/core-js/internals/iterators.js","../node_modules/core-js/internals/is-array-iterator-method.js","../node_modules/core-js/internals/get-iterator-method.js","../node_modules/core-js/internals/get-iterator.js","../node_modules/core-js/internals/iterator-close.js","../node_modules/core-js/internals/iterate.js","../node_modules/core-js/internals/check-correctness-of-iteration.js","../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","../node_modules/core-js/modules/es.promise.all.js","../node_modules/core-js/modules/es.promise.catch.js","../node_modules/core-js/modules/es.promise.race.js","../node_modules/core-js/modules/es.promise.reject.js","../node_modules/core-js/internals/promise-resolve.js","../node_modules/core-js/modules/es.promise.resolve.js","../node_modules/core-js/internals/object-keys.js","../node_modules/core-js/internals/object-define-properties.js","../node_modules/core-js/internals/object-create.js","../node_modules/core-js/internals/add-to-unscopables.js","../node_modules/core-js/internals/iterators-core.js","../node_modules/core-js/internals/correct-prototype-getter.js","../node_modules/core-js/internals/object-get-prototype-of.js","../node_modules/core-js/internals/iterator-create-constructor.js","../node_modules/core-js/internals/iterator-define.js","../node_modules/core-js/internals/create-iter-result-object.js","../node_modules/core-js/modules/es.array.iterator.js","../node_modules/core-js/modules/es.promise.all-settled.js","../node_modules/core-js/internals/to-string.js","../node_modules/core-js/internals/string-multibyte.js","../node_modules/core-js/modules/es.string.iterator.js","../node_modules/core-js/internals/dom-iterables.js","../node_modules/core-js/internals/dom-token-list-prototype.js","../node_modules/core-js/modules/web.dom-collections.iterator.js","../node_modules/core-js/internals/array-fill.js","../node_modules/core-js/modules/es.array.fill.js","../node_modules/core-js/internals/is-array.js","../node_modules/core-js/internals/create-property.js","../node_modules/core-js/internals/array-method-has-species-support.js","../node_modules/core-js/modules/es.array.slice.js","../node_modules/tslib/tslib.es6.js","../node_modules/eventemitter3/index.js","../node_modules/lodash-es/isArray.js","../node_modules/lodash-es/castArray.js","../node_modules/core-js/internals/array-species-constructor.js","../node_modules/core-js/internals/array-species-create.js","../node_modules/core-js/internals/array-iteration.js","../node_modules/core-js/modules/es.array.map.js","../node_modules/core-js/internals/object-assign.js","../node_modules/core-js/modules/es.object.assign.js","../node_modules/core-js/internals/array-slice-simple.js","../node_modules/core-js/internals/object-get-own-property-names-external.js","../node_modules/core-js/internals/array-buffer-non-extensible.js","../node_modules/core-js/internals/object-is-extensible.js","../node_modules/core-js/internals/freezing.js","../node_modules/core-js/internals/internal-metadata.js","../node_modules/core-js/internals/inherit-if-required.js","../node_modules/core-js/internals/collection.js","../node_modules/core-js/internals/define-built-ins.js","../node_modules/core-js/internals/collection-weak.js","../../src/constant.ts","../node_modules/core-js/modules/es.weak-set.constructor.js","../../src/calendar/Navigator.ts","../node_modules/core-js/internals/does-not-exceed-safe-integer.js","../node_modules/core-js/modules/es.array.concat.js","../node_modules/core-js/internals/array-method-is-strict.js","../node_modules/core-js/modules/es.array.join.js","../node_modules/core-js/internals/collection-strong.js","../node_modules/core-js/modules/es.map.constructor.js","../node_modules/core-js/internals/delete-property-or-throw.js","../node_modules/core-js/internals/array-sort.js","../node_modules/core-js/internals/engine-ff-version.js","../node_modules/core-js/internals/engine-is-ie-or-edge.js","../node_modules/core-js/internals/engine-webkit-version.js","../node_modules/core-js/modules/es.array.sort.js","../node_modules/core-js/internals/array-for-each.js","../node_modules/core-js/modules/web.dom-collections.for-each.js","../../src/helpers/PositionHelper.ts","../../src/domain/DomainCoordinates.ts","../../src/domain/DomainPainter.ts","../node_modules/core-js/modules/es.array.includes.js","../node_modules/core-js/modules/es.array.filter.js","../node_modules/core-js/internals/call-with-safe-iteration-closing.js","../node_modules/core-js/internals/array-from.js","../node_modules/core-js/modules/es.array.from.js","../../src/calendar/DomainCollection.ts","../../src/domain/DomainLabelPainter.ts","../node_modules/core-js/internals/whitespaces.js","../node_modules/core-js/internals/string-trim.js","../node_modules/core-js/internals/string-trim-forced.js","../node_modules/core-js/modules/es.string.trim.js","../../src/subDomain/SubDomainPainter.ts","../../src/domain/DomainsContainerPainter.ts","../../src/plugins/PluginPainter.ts","../../src/calendar/CalendarPainter.ts","../node_modules/lodash-es/_freeGlobal.js","../node_modules/lodash-es/_root.js","../node_modules/lodash-es/_Symbol.js","../node_modules/lodash-es/_getRawTag.js","../node_modules/lodash-es/_objectToString.js","../node_modules/lodash-es/_baseGetTag.js","../node_modules/lodash-es/isObject.js","../node_modules/lodash-es/isFunction.js","../node_modules/core-js/modules/es.object.keys.js","../node_modules/core-js/internals/is-regexp.js","../node_modules/core-js/modules/es.string.starts-with.js","../node_modules/core-js/internals/not-a-regexp.js","../node_modules/core-js/internals/correct-is-regexp-logic.js","../node_modules/core-js/internals/object-to-array.js","../node_modules/core-js/modules/es.object.entries.js","../node_modules/@observablehq/plot/src/defined.js","../node_modules/isoformat/src/parse.js","../node_modules/@observablehq/plot/src/time.js","../node_modules/@observablehq/plot/src/options.js","../node_modules/@observablehq/plot/src/scales/index.js","../node_modules/@observablehq/plot/src/symbol.js","../node_modules/@observablehq/plot/src/warnings.js","../node_modules/@observablehq/plot/src/scales/schemes.js","../node_modules/@observablehq/plot/src/scales/quantitative.js","../node_modules/@observablehq/plot/src/scales/diverging.js","../node_modules/@observablehq/plot/src/scales/temporal.js","../node_modules/@observablehq/plot/src/scales/ordinal.js","../node_modules/@observablehq/plot/src/scales.js","../../src/scale.ts","../../src/calendar/Populator.ts","../node_modules/lodash-es/eq.js","../node_modules/lodash-es/_assocIndexOf.js","../node_modules/lodash-es/_listCacheDelete.js","../node_modules/lodash-es/_ListCache.js","../node_modules/lodash-es/_listCacheClear.js","../node_modules/lodash-es/_listCacheGet.js","../node_modules/lodash-es/_listCacheHas.js","../node_modules/lodash-es/_listCacheSet.js","../node_modules/lodash-es/_coreJsData.js","../node_modules/lodash-es/_isMasked.js","../node_modules/lodash-es/_toSource.js","../node_modules/lodash-es/_baseIsNative.js","../node_modules/lodash-es/_getNative.js","../node_modules/lodash-es/_getValue.js","../node_modules/lodash-es/_Map.js","../node_modules/lodash-es/_nativeCreate.js","../node_modules/lodash-es/_hashGet.js","../node_modules/lodash-es/_hashHas.js","../node_modules/lodash-es/_Hash.js","../node_modules/lodash-es/_getMapData.js","../node_modules/lodash-es/_isKeyable.js","../node_modules/lodash-es/_MapCache.js","../node_modules/lodash-es/_hashClear.js","../node_modules/lodash-es/_hashDelete.js","../node_modules/lodash-es/_hashSet.js","../node_modules/lodash-es/_mapCacheClear.js","../node_modules/lodash-es/_mapCacheDelete.js","../node_modules/lodash-es/_mapCacheGet.js","../node_modules/lodash-es/_mapCacheHas.js","../node_modules/lodash-es/_mapCacheSet.js","../node_modules/lodash-es/_Stack.js","../node_modules/lodash-es/_stackClear.js","../node_modules/lodash-es/_stackDelete.js","../node_modules/lodash-es/_stackGet.js","../node_modules/lodash-es/_stackHas.js","../node_modules/lodash-es/_stackSet.js","../node_modules/lodash-es/_defineProperty.js","../node_modules/lodash-es/_baseAssignValue.js","../node_modules/lodash-es/_assignMergeValue.js","../node_modules/lodash-es/_baseFor.js","../node_modules/lodash-es/_createBaseFor.js","../node_modules/lodash-es/_cloneBuffer.js","../node_modules/lodash-es/_Uint8Array.js","../node_modules/lodash-es/_cloneTypedArray.js","../node_modules/lodash-es/_cloneArrayBuffer.js","../node_modules/lodash-es/_baseCreate.js","../node_modules/lodash-es/_overArg.js","../node_modules/lodash-es/_getPrototype.js","../node_modules/lodash-es/_isPrototype.js","../node_modules/lodash-es/isObjectLike.js","../node_modules/lodash-es/_baseIsArguments.js","../node_modules/lodash-es/isArguments.js","../node_modules/lodash-es/isLength.js","../node_modules/lodash-es/isArrayLike.js","../node_modules/lodash-es/isBuffer.js","../node_modules/lodash-es/stubFalse.js","../node_modules/lodash-es/isPlainObject.js","../node_modules/lodash-es/_baseIsTypedArray.js","../node_modules/lodash-es/_nodeUtil.js","../node_modules/lodash-es/_baseUnary.js","../node_modules/lodash-es/isTypedArray.js","../node_modules/lodash-es/_safeGet.js","../node_modules/lodash-es/_assignValue.js","../node_modules/lodash-es/_isIndex.js","../node_modules/lodash-es/_arrayLikeKeys.js","../node_modules/lodash-es/_baseTimes.js","../node_modules/lodash-es/_baseKeysIn.js","../node_modules/lodash-es/_nativeKeysIn.js","../node_modules/lodash-es/keysIn.js","../node_modules/lodash-es/toPlainObject.js","../node_modules/lodash-es/_copyObject.js","../node_modules/lodash-es/_baseMergeDeep.js","../node_modules/lodash-es/isArrayLikeObject.js","../node_modules/lodash-es/_copyArray.js","../node_modules/lodash-es/_initCloneObject.js","../node_modules/lodash-es/_baseMerge.js","../node_modules/lodash-es/identity.js","../node_modules/lodash-es/_overRest.js","../node_modules/lodash-es/_baseSetToString.js","../node_modules/lodash-es/constant.js","../node_modules/lodash-es/_shortOut.js","../node_modules/lodash-es/_setToString.js","../node_modules/lodash-es/_baseRest.js","../node_modules/lodash-es/_apply.js","../node_modules/lodash-es/mergeWith.js","../node_modules/lodash-es/_createAssigner.js","../node_modules/lodash-es/_isIterateeCall.js","../node_modules/lodash-es/_SetCache.js","../node_modules/lodash-es/_arraySome.js","../node_modules/lodash-es/_setCacheAdd.js","../node_modules/lodash-es/_setCacheHas.js","../node_modules/lodash-es/_equalArrays.js","../node_modules/lodash-es/_cacheHas.js","../node_modules/lodash-es/_mapToArray.js","../node_modules/lodash-es/_setToArray.js","../node_modules/lodash-es/_equalByTag.js","../node_modules/lodash-es/_getSymbols.js","../node_modules/lodash-es/_arrayFilter.js","../node_modules/lodash-es/stubArray.js","../node_modules/lodash-es/_nativeKeys.js","../node_modules/lodash-es/_baseKeys.js","../node_modules/lodash-es/keys.js","../node_modules/lodash-es/_getAllKeys.js","../node_modules/lodash-es/_baseGetAllKeys.js","../node_modules/lodash-es/_arrayPush.js","../node_modules/lodash-es/_equalObjects.js","../node_modules/lodash-es/_DataView.js","../node_modules/lodash-es/_Promise.js","../node_modules/lodash-es/_Set.js","../node_modules/lodash-es/_WeakMap.js","../node_modules/lodash-es/_getTag.js","../node_modules/lodash-es/_baseIsEqualDeep.js","../node_modules/lodash-es/_baseIsEqual.js","../node_modules/lodash-es/isEqual.js","../node_modules/lodash-es/_baseHas.js","../node_modules/lodash-es/isSymbol.js","../node_modules/lodash-es/_isKey.js","../node_modules/lodash-es/memoize.js","../node_modules/lodash-es/_stringToPath.js","../node_modules/lodash-es/_memoizeCapped.js","../node_modules/lodash-es/_baseToString.js","../node_modules/lodash-es/_arrayMap.js","../node_modules/lodash-es/_castPath.js","../node_modules/lodash-es/toString.js","../node_modules/lodash-es/_toKey.js","../node_modules/lodash-es/has.js","../node_modules/lodash-es/_hasPath.js","../node_modules/lodash-es/get.js","../node_modules/lodash-es/_baseGet.js","../node_modules/lodash-es/set.js","../node_modules/lodash-es/_baseSet.js","../../src/options/OptionsPreProcessors.ts","../node_modules/core-js/internals/regexp-exec.js","../node_modules/lodash-es/isString.js","../../src/options/Options.ts","../node_modules/core-js/internals/regexp-flags.js","../node_modules/core-js/internals/regexp-sticky-helpers.js","../node_modules/core-js/internals/regexp-unsupported-dot-all.js","../node_modules/core-js/internals/regexp-unsupported-ncg.js","../node_modules/core-js/modules/es.regexp.exec.js","../node_modules/core-js/internals/fix-regexp-well-known-symbol-logic.js","../node_modules/core-js/internals/advance-string-index.js","../node_modules/core-js/internals/get-substitution.js","../node_modules/core-js/internals/regexp-exec-abstract.js","../node_modules/core-js/modules/es.string.replace.js","../../src/DataFetcher.ts","../node_modules/core-js/modules/es.function.name.js","../node_modules/dayjs/dayjs.min.js","../node_modules/dayjs/plugin/weekOfYear.js","../node_modules/dayjs/plugin/dayOfYear.js","../node_modules/dayjs/plugin/weekday.js","../node_modules/dayjs/plugin/minMax.js","../node_modules/dayjs/plugin/isoWeeksInYear.js","../node_modules/dayjs/plugin/isoWeek.js","../node_modules/dayjs/plugin/isLeapYear.js","../node_modules/dayjs/plugin/advancedFormat.js","../node_modules/dayjs/plugin/utc.js","../node_modules/dayjs/plugin/timezone.js","../node_modules/dayjs/plugin/localeData.js","../node_modules/dayjs/plugin/localizedFormat.js","../node_modules/dayjs/plugin/updateLocale.js","../../src/helpers/DateHelper.ts","../node_modules/core-js/modules/es.string.includes.js","../../src/options/OptionsValidator.ts","../node_modules/core-js/modules/es.set.constructor.js","../../src/plugins/PluginManager.ts","../../src/templates/index.ts","../../src/templates/minute.ts","../../src/templates/hour.ts","../../src/templates/day.ts","../../src/templates/xDay.ts","../../src/templates/ghDay.ts","../../src/templates/week.ts","../../src/templates/month.ts","../../src/templates/year.ts","../../src/TemplateCollection.ts","../../src/CalHeatmap.ts","../../src/version.ts"],"sourcesContent":["'use strict';\nvar check = function (it) {\n return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n check(typeof this == 'object' && this) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.34.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',\n license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',\n source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-function-prototype-bind -- safe\n var test = (function () { /* empty */ }).bind();\n // eslint-disable-next-line no-prototype-builtins -- safe\n return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n return function () {\n return call.apply(fn, arguments);\n };\n};\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n return it === null || it === undefined;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n return it;\n};\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol('symbol detection');\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n // of course, fail.\n return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name)) {\n WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n ? Symbol[name]\n : createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar documentAll = typeof document == 'object' && document.all;\n\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nvar IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;\n\nmodule.exports = {\n all: documentAll,\n IS_HTMLDDA: IS_HTMLDDA\n};\n","'use strict';\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = $documentAll.IS_HTMLDDA ? function (argument) {\n return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n return typeof argument == 'function';\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\nmodule.exports = $documentAll.IS_HTMLDDA ? function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;\n} : function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a !== 7;\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype !== 42;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n try {\n return $String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw new $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n /* eslint-disable no-self-assign -- prototype methods protection */\n store.get = store.get;\n store.has = store.has;\n store.set = store.set;\n /* eslint-enable no-self-assign -- prototype methods protection */\n set = function (it, metadata) {\n if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n store.set(it, metadata);\n return metadata;\n };\n get = function (it) {\n return store.get(it) || {};\n };\n has = function (it) {\n return store.has(it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nmodule.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (options && options.getter) name = 'get ' + name;\n if (options && options.setter) name = 'set ' + name;\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n else value.name = name;\n }\n if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n defineProperty(value, 'length', { value: options.arity });\n }\n try {\n if (options && hasOwn(options, 'constructor') && options.constructor) {\n if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n } else if (value.prototype) value.prototype = undefined;\n } catch (error) { /* empty */ }\n var state = enforceInternalState(value);\n if (!hasOwn(state, 'source')) {\n state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- NaN check\n return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el !== el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value !== value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value === POLYFILL ? true\n : value === NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.dontCallGetSet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || defineGlobalProperty(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.dontCallGetSet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n defineBuiltIn(target, key, sourceProperty, options);\n }\n};\n","'use strict';\nvar global = require('../internals/global');\nvar classof = require('../internals/classof-raw');\n\nmodule.exports = classof(global.process) === 'process';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nmodule.exports = function (object, key, method) {\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));\n } catch (error) { /* empty */ }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw new $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","'use strict';\n/* eslint-disable no-proto -- safe */\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (target, TAG, STATIC) {\n if (target && !STATIC) target = target.prototype;\n if (target && !hasOwn(target, TO_STRING_TAG)) {\n defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","'use strict';\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineProperty = require('../internals/object-define-property');\n\nmodule.exports = function (target, name, descriptor) {\n if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });\n if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });\n return defineProperty.f(target, name, descriptor);\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineBuiltInAccessor(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw new $TypeError('Incorrect invocation');\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.test(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n }\n try {\n // we can't check .prototype since constructors produced by .bind haven't it\n // `Function#toString` throws on some built-it function in some legacy engines\n // (for example, `DOMQuad` and similar in FF41-)\n return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n } catch (error) {\n return true;\n }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar $location, defer, channel, port;\n\nfails(function () {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n $location = global.location;\n});\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar eventListener = function (event) {\n run(event.data);\n};\n\nvar globalPostMessageDefer = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), $location.protocol + '//' + $location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(handler) {\n validateArgumentsLength(arguments.length, 1);\n var fn = isCallable(handler) ? handler : Function(handler);\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(fn, undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = eventListener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n $location && $location.protocol !== 'file:' &&\n !fails(globalPostMessageDefer)\n ) {\n defer = globalPostMessageDefer;\n global.addEventListener('message', eventListener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","'use strict';\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a constructor');\n};\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","'use strict';\nvar classofRaw = require('../internals/classof-raw');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (fn) {\n // Nashorn bug:\n // https://github.com/zloirock/core-js/issues/1128\n // https://github.com/zloirock/core-js/issues/1130\n if (classofRaw(fn) === 'Function') return uncurryThis(fn);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","'use strict';\nvar $TypeError = TypeError;\n\nmodule.exports = function (passed, required) {\n if (passed < required) throw new $TypeError('Not enough arguments');\n return passed;\n};\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line redos/no-vulnerable -- safe\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","'use strict';\nvar Queue = function () {\n this.head = null;\n this.tail = null;\n};\n\nQueue.prototype = {\n add: function (item) {\n var entry = { item: item, next: null };\n var tail = this.tail;\n if (tail) tail.next = entry;\n else this.head = entry;\n this.tail = entry;\n },\n get: function () {\n var entry = this.head;\n if (entry) {\n var next = this.head = entry.next;\n if (next === null) this.tail = null;\n return entry.item;\n }\n }\n};\n\nmodule.exports = Queue;\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar Queue = require('../internals/queue');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar microtask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\nvar notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!microtask) {\n var queue = new Queue();\n\n var flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (fn = queue.get()) try {\n fn();\n } catch (error) {\n if (queue.head) notify();\n throw error;\n }\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessage\n // - onreadystatechange\n // - setTimeout\n } else {\n // `webpack` dev server bug on IE global methods - use bind(fn, global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n\n microtask = function (fn) {\n if (!queue.head) notify();\n queue.add(fn);\n };\n}\n\nmodule.exports = microtask;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","'use strict';\nvar global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n && typeof window == 'object'\n && typeof document == 'object';\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n // Detect correctness of subclassing with @@species support\n var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar $TypeError = TypeError;\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar IS_NODE = require('../internals/engine-is-node');\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar perform = require('../internals/perform');\nvar Queue = require('../internals/queue');\nvar InternalStateModule = require('../internals/internal-state');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar PromiseConstructorDetection = require('../internals/promise-constructor-detection');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\n\nvar PROMISE = 'Promise';\nvar FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;\nvar NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;\nvar NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar PromiseConstructor = NativePromiseConstructor;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar callReaction = function (reaction, state) {\n var value = state.value;\n var ok = state.state === FULFILLED;\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(new TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n microtask(function () {\n var reactions = state.reactions;\n var reaction;\n while (reaction = reactions.get()) {\n callReaction(reaction, state);\n }\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw new TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED_PROMISE_CONSTRUCTOR) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalPromiseState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n\n PromisePrototype = PromiseConstructor.prototype;\n\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: new Queue(),\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n state.parent = true;\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n if (state.state === PENDING) state.reactions.add(reaction);\n else microtask(function () {\n callReaction(reaction, state);\n });\n return reaction.promise;\n });\n\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalPromiseState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!NATIVE_PROMISE_SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n","'use strict';\nmodule.exports = function (a, b) {\n try {\n // eslint-disable-next-line no-console -- safe\n arguments.length === 1 ? console.error(a) : console.error(a, b);\n } catch (error) { /* empty */ }\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw new $TypeError(tryToString(argument) + ' is not iterable');\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_RECORD = !!(options && options.IS_RECORD);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_RECORD) {\n iterator = iterable.iterator;\n } else if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = IS_RECORD ? iterable.next : iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n try {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n } catch (error) { return false; } // workaround of old WebKit + `eval` bug\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.all` method\n// https://tc39.es/ecma262/#sec-promise.all\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar defineBuiltIn = require('../internals/define-built-in');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\n\n// `Promise.prototype.catch` method\n// https://tc39.es/ecma262/#sec-promise.prototype.catch\n$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n});\n\n// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromiseConstructor)) {\n var method = getBuiltIn('Promise').prototype['catch'];\n if (NativePromisePrototype['catch'] !== method) {\n defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.race` method\n// https://tc39.es/ecma262/#sec-promise.race\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\n// `Promise.reject` method\n// https://tc39.es/ecma262/#sec-promise.reject\n$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n reject: function reject(r) {\n var capability = newPromiseCapabilityModule.f(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar promiseResolve = require('../internals/promise-resolve');\n\nvar PromiseConstructorWrapper = getBuiltIn('Promise');\nvar CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;\n\n// `Promise.resolve` method\n// https://tc39.es/ecma262/#sec-promise.resolve\n$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {\n resolve: function resolve(x) {\n return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);\n }\n});\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var props = toIndexedObject(Properties);\n var keys = objectKeys(Properties);\n var length = keys.length;\n var index = 0;\n var key;\n while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n return O;\n};\n","'use strict';\n/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n activeXDocument.write(scriptTag(''));\n activeXDocument.close();\n var temp = activeXDocument.parentWindow.Object;\n activeXDocument = null; // avoid memory leak\n return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = documentCreateElement('iframe');\n var JS = 'java' + SCRIPT + ':';\n var iframeDocument;\n iframe.style.display = 'none';\n html.appendChild(iframe);\n // https://github.com/zloirock/core-js/issues/475\n iframe.src = String(JS);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(scriptTag('document.F=Object'));\n iframeDocument.close();\n return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n try {\n activeXDocument = new ActiveXObject('htmlfile');\n } catch (error) { /* ignore */ }\n NullProtoObject = typeof document != 'undefined'\n ? document.domain && activeXDocument\n ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n : NullProtoObjectViaIFrame()\n : NullProtoObjectViaActiveX(activeXDocument); // WSH\n var length = enumBugKeys.length;\n while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n EmptyConstructor[PROTOTYPE] = anObject(O);\n result = new EmptyConstructor();\n EmptyConstructor[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = NullProtoObject();\n return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] === undefined) {\n defineProperty(ArrayPrototype, UNSCOPABLES, {\n configurable: true,\n value: create(null)\n });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n arrayIterator = [].keys();\n // Safari 8 has buggy iterators w/o `next`\n if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n else {\n PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {\n var test = {};\n // FF44- legacy iterators case\n return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n defineBuiltIn(IteratorPrototype, ITERATOR, function () {\n return this;\n });\n}\n\nmodule.exports = {\n IteratorPrototype: IteratorPrototype,\n BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n function F() { /* empty */ }\n F.prototype.constructor = null;\n // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar $Object = Object;\nvar ObjectPrototype = $Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n// eslint-disable-next-line es/no-object-getprototypeof -- safe\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {\n var object = toObject(O);\n if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n var constructor = object.constructor;\n if (isCallable(constructor) && object instanceof constructor) {\n return constructor.prototype;\n } return object instanceof $Object ? ObjectPrototype : null;\n};\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {\n var TO_STRING_TAG = NAME + ' Iterator';\n IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });\n setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n Iterators[TO_STRING_TAG] = returnThis;\n return IteratorConstructor;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/iterator-create-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n createIteratorConstructor(IteratorConstructor, NAME, next);\n\n var getIterationMethod = function (KIND) {\n if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];\n\n switch (KIND) {\n case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n }\n\n return function () { return new IteratorConstructor(this); };\n };\n\n var TO_STRING_TAG = NAME + ' Iterator';\n var INCORRECT_VALUES_NAME = false;\n var IterablePrototype = Iterable.prototype;\n var nativeIterator = IterablePrototype[ITERATOR]\n || IterablePrototype['@@iterator']\n || DEFAULT && IterablePrototype[DEFAULT];\n var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n var CurrentIteratorPrototype, methods, KEY;\n\n // fix native\n if (anyNativeIterator) {\n CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n if (setPrototypeOf) {\n setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);\n }\n }\n // Set @@toStringTag to native iterators\n setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n }\n }\n\n // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n } else {\n INCORRECT_VALUES_NAME = true;\n defaultIterator = function values() { return call(nativeIterator, this); };\n }\n }\n\n // export additional methods\n if (DEFAULT) {\n methods = {\n values: getIterationMethod(VALUES),\n keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n entries: getIterationMethod(ENTRIES)\n };\n if (FORCED) for (KEY in methods) {\n if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n defineBuiltIn(IterablePrototype, KEY, methods[KEY]);\n }\n } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n }\n\n // define iterator\n if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n }\n Iterators[NAME] = defaultIterator;\n\n return methods;\n};\n","'use strict';\n// `CreateIterResultObject` abstract operation\n// https://tc39.es/ecma262/#sec-createiterresultobject\nmodule.exports = function (value, done) {\n return { value: value, done: done };\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineProperty = require('../internals/object-define-property').f;\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar IS_PURE = require('../internals/is-pure');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n setInternalState(this, {\n type: ARRAY_ITERATOR,\n target: toIndexedObject(iterated), // target\n index: 0, // next index\n kind: kind // kind\n });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n var state = getInternalState(this);\n var target = state.target;\n var index = state.index++;\n if (!target || index >= target.length) {\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n switch (state.kind) {\n case 'keys': return createIterResultObject(index, false);\n case 'values': return createIterResultObject(target[index], false);\n } return createIterResultObject([index, target[index]], false);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nvar values = Iterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n// V8 ~ Chrome 45- bug\nif (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {\n defineProperty(values, 'name', { value: 'values' });\n} catch (error) { /* empty */ }\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-promise.allsettled\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n allSettled: function allSettled(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call(promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = { status: 'fulfilled', value: value };\n --remaining || resolve(values);\n }, function (error) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = { status: 'rejected', reason: error };\n --remaining || resolve(values);\n });\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar classof = require('../internals/classof');\n\nvar $String = String;\n\nmodule.exports = function (argument) {\n if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n return $String(argument);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n return function ($this, pos) {\n var S = toString(requireObjectCoercible($this));\n var position = toIntegerOrInfinity(pos);\n var size = S.length;\n var first, second;\n if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n first = charCodeAt(S, position);\n return first < 0xD800 || first > 0xDBFF || position + 1 === size\n || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n ? CONVERT_TO_STRING\n ? charAt(S, position)\n : first\n : CONVERT_TO_STRING\n ? stringSlice(S, position, position + 2)\n : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n };\n};\n\nmodule.exports = {\n // `String.prototype.codePointAt` method\n // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n codeAt: createMethod(false),\n // `String.prototype.at` method\n // https://github.com/mathiasbynens/String.prototype.at\n charAt: createMethod(true)\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n setInternalState(this, {\n type: STRING_ITERATOR,\n string: toString(iterated),\n index: 0\n });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n var state = getInternalState(this);\n var string = state.string;\n var index = state.index;\n var point;\n if (index >= string.length) return createIterResultObject(undefined, true);\n point = charAt(string, index);\n state.index += point.length;\n return createIterResultObject(point, false);\n});\n","'use strict';\n// iterable DOM collections\n// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods\nmodule.exports = {\n CSSRuleList: 0,\n CSSStyleDeclaration: 0,\n CSSValueList: 0,\n ClientRectList: 0,\n DOMRectList: 0,\n DOMStringList: 0,\n DOMTokenList: 1,\n DataTransferItemList: 0,\n FileList: 0,\n HTMLAllCollection: 0,\n HTMLCollection: 0,\n HTMLFormElement: 0,\n HTMLSelectElement: 0,\n MediaList: 0,\n MimeTypeArray: 0,\n NamedNodeMap: 0,\n NodeList: 1,\n PaintRequestList: 0,\n Plugin: 0,\n PluginArray: 0,\n SVGLengthList: 0,\n SVGNumberList: 0,\n SVGPathSegList: 0,\n SVGPointList: 0,\n SVGStringList: 0,\n SVGTransformList: 0,\n SourceBufferList: 0,\n StyleSheetList: 0,\n TextTrackCueList: 0,\n TextTrackList: 0,\n TouchList: 0\n};\n","'use strict';\n// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`\nvar documentCreateElement = require('../internals/document-create-element');\n\nvar classList = documentCreateElement('span').classList;\nvar DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;\n\nmodule.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nvar handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {\n if (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n } catch (error) {\n CollectionPrototype[ITERATOR] = ArrayValues;\n }\n setToStringTag(CollectionPrototype, COLLECTION_NAME, true);\n if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n } catch (error) {\n CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n }\n }\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);\n}\n\nhandlePrototype(DOMTokenListPrototype, 'DOMTokenList');\n","'use strict';\nvar toObject = require('../internals/to-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.fill` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.fill\nmodule.exports = function fill(value /* , start = 0, end = @length */) {\n var O = toObject(this);\n var length = lengthOfArrayLike(O);\n var argumentsLength = arguments.length;\n var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length);\n var end = argumentsLength > 2 ? arguments[2] : undefined;\n var endPos = end === undefined ? length : toAbsoluteIndex(end, length);\n while (endPos > index) O[index++] = value;\n return O;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar fill = require('../internals/array-fill');\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// `Array.prototype.fill` method\n// https://tc39.es/ecma262/#sec-array.prototype.fill\n$({ target: 'Array', proto: true }, {\n fill: fill\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('fill');\n","'use strict';\nvar classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n return classof(argument) === 'Array';\n};\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n var propertyKey = toPropertyKey(key);\n if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n else object[propertyKey] = value;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (METHOD_NAME) {\n // We can't use this feature detection in V8 since it causes\n // deoptimization and serious performance degradation\n // https://github.com/zloirock/core-js/issues/677\n return V8_VERSION >= 51 || !fails(function () {\n var array = [];\n var constructor = array.constructor = {};\n constructor[SPECIES] = function () {\n return { foo: 1 };\n };\n return array[METHOD_NAME](Boolean).foo !== 1;\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar createProperty = require('../internals/create-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar nativeSlice = require('../internals/array-slice');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\nvar max = Math.max;\n\n// `Array.prototype.slice` method\n// https://tc39.es/ecma262/#sec-array.prototype.slice\n// fallback for not array-like ES3 strings and DOM objects\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n slice: function slice(start, end) {\n var O = toIndexedObject(this);\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible\n var Constructor, result, n;\n if (isArray(O)) {\n Constructor = O.constructor;\n // cross-realm fallback\n if (isConstructor(Constructor) && (Constructor === $Array || isArray(Constructor.prototype))) {\n Constructor = undefined;\n } else if (isObject(Constructor)) {\n Constructor = Constructor[SPECIES];\n if (Constructor === null) Constructor = undefined;\n }\n if (Constructor === $Array || Constructor === undefined) {\n return nativeSlice(O, k, fin);\n }\n }\n result = new (Constructor === undefined ? $Array : Constructor)(max(fin - k, 0));\n for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n }\n});\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n var _, done = false;\r\n for (var i = decorators.length - 1; i >= 0; i--) {\r\n var context = {};\r\n for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n if (kind === \"accessor\") {\r\n if (result === void 0) continue;\r\n if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n if (_ = accept(result.get)) descriptor.get = _;\r\n if (_ = accept(result.set)) descriptor.set = _;\r\n if (_ = accept(result.init)) initializers.unshift(_);\r\n }\r\n else if (_ = accept(result)) {\r\n if (kind === \"field\") initializers.unshift(_);\r\n else descriptor[key] = _;\r\n }\r\n }\r\n if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n var useValue = arguments.length > 2;\r\n for (var i = 0; i < initializers.length; i++) {\r\n value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n }\r\n return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n 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;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n var desc = Object.getOwnPropertyDescriptor(m, k);\r\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n desc = { enumerable: true, get: function() { return m[k]; } };\r\n }\r\n Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport default {\r\n __extends,\r\n __assign,\r\n __rest,\r\n __decorate,\r\n __param,\r\n __metadata,\r\n __awaiter,\r\n __generator,\r\n __createBinding,\r\n __exportStar,\r\n __values,\r\n __read,\r\n __spread,\r\n __spreadArrays,\r\n __spreadArray,\r\n __await,\r\n __asyncGenerator,\r\n __asyncDelegator,\r\n __asyncValues,\r\n __makeTemplateObject,\r\n __importStar,\r\n __importDefault,\r\n __classPrivateFieldGet,\r\n __classPrivateFieldSet,\r\n __classPrivateFieldIn,\r\n};\r\n","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n Events.prototype = Object.create(null);\n\n //\n // This hack is needed because the `__proto__` property is still inherited in\n // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n //\n if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @private\n */\nfunction EE(fn, context, once) {\n this.fn = fn;\n this.context = context;\n this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n if (typeof fn !== 'function') {\n throw new TypeError('The listener must be a function');\n }\n\n var listener = new EE(fn, context || emitter, once)\n , evt = prefix ? prefix + event : event;\n\n if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n else emitter._events[evt] = [emitter._events[evt], listener];\n\n return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n if (--emitter._eventsCount === 0) emitter._events = new Events();\n else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @public\n */\nfunction EventEmitter() {\n this._events = new Events();\n this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n var names = []\n , events\n , name;\n\n if (this._eventsCount === 0) return names;\n\n for (name in (events = this._events)) {\n if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n }\n\n if (Object.getOwnPropertySymbols) {\n return names.concat(Object.getOwnPropertySymbols(events));\n }\n\n return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n var evt = prefix ? prefix + event : event\n , handlers = this._events[evt];\n\n if (!handlers) return [];\n if (handlers.fn) return [handlers.fn];\n\n for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n ee[i] = handlers[i].fn;\n }\n\n return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n var evt = prefix ? prefix + event : event\n , listeners = this._events[evt];\n\n if (!listeners) return 0;\n if (listeners.fn) return 1;\n return listeners.length;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n var evt = prefix ? prefix + event : event;\n\n if (!this._events[evt]) return false;\n\n var listeners = this._events[evt]\n , len = arguments.length\n , args\n , i;\n\n if (listeners.fn) {\n if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n switch (len) {\n case 1: return listeners.fn.call(listeners.context), true;\n case 2: return listeners.fn.call(listeners.context, a1), true;\n case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n }\n\n for (i = 1, args = new Array(len -1); i < len; i++) {\n args[i - 1] = arguments[i];\n }\n\n listeners.fn.apply(listeners.context, args);\n } else {\n var length = listeners.length\n , j;\n\n for (i = 0; i < length; i++) {\n if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n switch (len) {\n case 1: listeners[i].fn.call(listeners[i].context); break;\n case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n default:\n if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n args[j - 1] = arguments[j];\n }\n\n listeners[i].fn.apply(listeners[i].context, args);\n }\n }\n }\n\n return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n return addListener(this, event, fn, context, false);\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n return addListener(this, event, fn, context, true);\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n var evt = prefix ? prefix + event : event;\n\n if (!this._events[evt]) return this;\n if (!fn) {\n clearEvent(this, evt);\n return this;\n }\n\n var listeners = this._events[evt];\n\n if (listeners.fn) {\n if (\n listeners.fn === fn &&\n (!once || listeners.once) &&\n (!context || listeners.context === context)\n ) {\n clearEvent(this, evt);\n }\n } else {\n for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n if (\n listeners[i].fn !== fn ||\n (once && !listeners[i].once) ||\n (context && listeners[i].context !== context)\n ) {\n events.push(listeners[i]);\n }\n }\n\n //\n // Reset the array, or remove it completely if we have no more listeners.\n //\n if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n else clearEvent(this, evt);\n }\n\n return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {(String|Symbol)} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n var evt;\n\n if (event) {\n evt = prefix ? prefix + event : event;\n if (this._events[evt]) clearEvent(this, evt);\n } else {\n this._events = new Events();\n this._eventsCount = 0;\n }\n\n return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n module.exports = EventEmitter;\n}\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nexport default isArray;\n","import isArray from './isArray.js';\n\n/**\n * Casts `value` as an array if it's not one.\n *\n * @static\n * @memberOf _\n * @since 4.4.0\n * @category Lang\n * @param {*} value The value to inspect.\n * @returns {Array} Returns the cast array.\n * @example\n *\n * _.castArray(1);\n * // => [1]\n *\n * _.castArray({ 'a': 1 });\n * // => [{ 'a': 1 }]\n *\n * _.castArray('abc');\n * // => ['abc']\n *\n * _.castArray(null);\n * // => [null]\n *\n * _.castArray(undefined);\n * // => [undefined]\n *\n * _.castArray();\n * // => []\n *\n * var array = [1, 2, 3];\n * console.log(_.castArray(array) === array);\n * // => true\n */\nfunction castArray() {\n if (!arguments.length) {\n return [];\n }\n var value = arguments[0];\n return isArray(value) ? value : [value];\n}\n\nexport default castArray;\n","'use strict';\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n var C;\n if (isArray(originalArray)) {\n C = originalArray.constructor;\n // cross-realm fallback\n if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;\n else if (isObject(C)) {\n C = C[SPECIES];\n if (C === null) C = undefined;\n }\n } return C === undefined ? $Array : C;\n};\n","'use strict';\nvar arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n var IS_MAP = TYPE === 1;\n var IS_FILTER = TYPE === 2;\n var IS_SOME = TYPE === 3;\n var IS_EVERY = TYPE === 4;\n var IS_FIND_INDEX = TYPE === 6;\n var IS_FILTER_REJECT = TYPE === 7;\n var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;\n return function ($this, callbackfn, that, specificCreate) {\n var O = toObject($this);\n var self = IndexedObject(O);\n var length = lengthOfArrayLike(self);\n var boundFunction = bind(callbackfn, that);\n var index = 0;\n var create = specificCreate || arraySpeciesCreate;\n var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n var value, result;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n value = self[index];\n result = boundFunction(value, index, O);\n if (TYPE) {\n if (IS_MAP) target[index] = result; // map\n else if (result) switch (TYPE) {\n case 3: return true; // some\n case 5: return value; // find\n case 6: return index; // findIndex\n case 2: push(target, value); // filter\n } else switch (TYPE) {\n case 4: return false; // every\n case 7: push(target, value); // filterReject\n }\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.forEach` method\n // https://tc39.es/ecma262/#sec-array.prototype.foreach\n forEach: createMethod(0),\n // `Array.prototype.map` method\n // https://tc39.es/ecma262/#sec-array.prototype.map\n map: createMethod(1),\n // `Array.prototype.filter` method\n // https://tc39.es/ecma262/#sec-array.prototype.filter\n filter: createMethod(2),\n // `Array.prototype.some` method\n // https://tc39.es/ecma262/#sec-array.prototype.some\n some: createMethod(3),\n // `Array.prototype.every` method\n // https://tc39.es/ecma262/#sec-array.prototype.every\n every: createMethod(4),\n // `Array.prototype.find` method\n // https://tc39.es/ecma262/#sec-array.prototype.find\n find: createMethod(5),\n // `Array.prototype.findIndex` method\n // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n findIndex: createMethod(6),\n // `Array.prototype.filterReject` method\n // https://github.com/tc39/proposal-array-filtering\n filterReject: createMethod(7)\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $map = require('../internals/array-iteration').map;\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');\n\n// `Array.prototype.map` method\n// https://tc39.es/ecma262/#sec-array.prototype.map\n// with adding support of @@species\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n map: function map(callbackfn /* , thisArg */) {\n return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol('assign detection');\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","'use strict';\nvar $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {\n assign: assign\n});\n","'use strict';\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\n\nvar $Array = Array;\nvar max = Math.max;\n\nmodule.exports = function (O, start, end) {\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n var result = $Array(max(fin - k, 0));\n var n = 0;\n for (; k < fin; k++, n++) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n};\n","'use strict';\n/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n try {\n return $getOwnPropertyNames(it);\n } catch (error) {\n return arraySlice(windowNames);\n }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n return windowNames && classof(it) === 'Window'\n ? getWindowNames(it)\n : $getOwnPropertyNames(toIndexedObject(it));\n};\n","'use strict';\n// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it\nvar fails = require('../internals/fails');\n\nmodule.exports = fails(function () {\n if (typeof ArrayBuffer == 'function') {\n var buffer = new ArrayBuffer(8);\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe\n if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar ARRAY_BUFFER_NON_EXTENSIBLE = require('../internals/array-buffer-non-extensible');\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar $isExtensible = Object.isExtensible;\nvar FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); });\n\n// `Object.isExtensible` method\n// https://tc39.es/ecma262/#sec-object.isextensible\nmodule.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) {\n if (!isObject(it)) return false;\n if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false;\n return $isExtensible ? $isExtensible(it) : true;\n} : $isExtensible;\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n return Object.isExtensible(Object.preventExtensions({}));\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar isExtensible = require('../internals/object-is-extensible');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar setMetadata = function (it) {\n defineProperty(it, METADATA, { value: {\n objectID: 'O' + id++, // object ID\n weakData: {} // weak collections IDs\n } });\n};\n\nvar fastKey = function (it, create) {\n // return a primitive with prefix\n if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return 'F';\n // not necessary to add metadata\n if (!create) return 'E';\n // add missing metadata\n setMetadata(it);\n // return object ID\n } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return true;\n // not necessary to add metadata\n if (!create) return false;\n // add missing metadata\n setMetadata(it);\n // return the store of weak collections IDs\n } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n return it;\n};\n\nvar enable = function () {\n meta.enable = function () { /* empty */ };\n REQUIRED = true;\n var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n var splice = uncurryThis([].splice);\n var test = {};\n test[METADATA] = 1;\n\n // prevent exposing of metadata key\n if (getOwnPropertyNames(test).length) {\n getOwnPropertyNamesModule.f = function (it) {\n var result = getOwnPropertyNames(it);\n for (var i = 0, length = result.length; i < length; i++) {\n if (result[i] === METADATA) {\n splice(result, i, 1);\n break;\n }\n } return result;\n };\n\n $({ target: 'Object', stat: true, forced: true }, {\n getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n });\n }\n};\n\nvar meta = module.exports = {\n enable: enable,\n fastKey: fastKey,\n getWeakData: getWeakData,\n onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n var NewTarget, NewTargetPrototype;\n if (\n // it can work only with native `setPrototypeOf`\n setPrototypeOf &&\n // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n isCallable(NewTarget = dummy.constructor) &&\n NewTarget !== Wrapper &&\n isObject(NewTargetPrototype = NewTarget.prototype) &&\n NewTargetPrototype !== Wrapper.prototype\n ) setPrototypeOf($this, NewTargetPrototype);\n return $this;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n var ADDER = IS_MAP ? 'set' : 'add';\n var NativeConstructor = global[CONSTRUCTOR_NAME];\n var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n var Constructor = NativeConstructor;\n var exported = {};\n\n var fixMethod = function (KEY) {\n var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n defineBuiltIn(NativePrototype, KEY,\n KEY === 'add' ? function add(value) {\n uncurriedNativeMethod(this, value === 0 ? 0 : value);\n return this;\n } : KEY === 'delete' ? function (key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'get' ? function get(key) {\n return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'has' ? function has(key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : function set(key, value) {\n uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n return this;\n }\n );\n };\n\n var REPLACE = isForced(\n CONSTRUCTOR_NAME,\n !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n new NativeConstructor().entries().next();\n }))\n );\n\n if (REPLACE) {\n // create collection constructor\n Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n InternalMetadataModule.enable();\n } else if (isForced(CONSTRUCTOR_NAME, true)) {\n var instance = new Constructor();\n // early implementations not supports chaining\n var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance;\n // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n // most early implementations doesn't supports iterables, most modern - not close it correctly\n // eslint-disable-next-line no-new -- required for testing\n var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n // for early implementations -0 and +0 not the same\n var BUGGY_ZERO = !IS_WEAK && fails(function () {\n // V8 ~ Chromium 42- fails only with 5+ elements\n var $instance = new NativeConstructor();\n var index = 5;\n while (index--) $instance[ADDER](index, index);\n return !$instance.has(-0);\n });\n\n if (!ACCEPT_ITERABLES) {\n Constructor = wrapper(function (dummy, iterable) {\n anInstance(dummy, NativePrototype);\n var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n return that;\n });\n Constructor.prototype = NativePrototype;\n NativePrototype.constructor = Constructor;\n }\n\n if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n fixMethod('delete');\n fixMethod('has');\n IS_MAP && fixMethod('get');\n }\n\n if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n // weak collections should not contains .clear method\n if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n }\n\n exported[CONSTRUCTOR_NAME] = Constructor;\n $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported);\n\n setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n return Constructor;\n};\n","'use strict';\nvar defineBuiltIn = require('../internals/define-built-in');\n\nmodule.exports = function (target, src, options) {\n for (var key in src) defineBuiltIn(target, key, src[key], options);\n return target;\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar getWeakData = require('../internals/internal-metadata').getWeakData;\nvar anInstance = require('../internals/an-instance');\nvar anObject = require('../internals/an-object');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar iterate = require('../internals/iterate');\nvar ArrayIterationModule = require('../internals/array-iteration');\nvar hasOwn = require('../internals/has-own-property');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\nvar find = ArrayIterationModule.find;\nvar findIndex = ArrayIterationModule.findIndex;\nvar splice = uncurryThis([].splice);\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (state) {\n return state.frozen || (state.frozen = new UncaughtFrozenStore());\n};\n\nvar UncaughtFrozenStore = function () {\n this.entries = [];\n};\n\nvar findUncaughtFrozen = function (store, key) {\n return find(store.entries, function (it) {\n return it[0] === key;\n });\n};\n\nUncaughtFrozenStore.prototype = {\n get: function (key) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) return entry[1];\n },\n has: function (key) {\n return !!findUncaughtFrozen(this, key);\n },\n set: function (key, value) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) entry[1] = value;\n else this.entries.push([key, value]);\n },\n 'delete': function (key) {\n var index = findIndex(this.entries, function (it) {\n return it[0] === key;\n });\n if (~index) splice(this.entries, index, 1);\n return !!~index;\n }\n};\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n id: id++,\n frozen: undefined\n });\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var data = getWeakData(anObject(key), true);\n if (data === true) uncaughtFrozenStore(state).set(key, value);\n else data[state.id] = value;\n return that;\n };\n\n defineBuiltIns(Prototype, {\n // `{ WeakMap, WeakSet }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.delete\n // https://tc39.es/ecma262/#sec-weakset.prototype.delete\n 'delete': function (key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state)['delete'](key);\n return data && hasOwn(data, state.id) && delete data[state.id];\n },\n // `{ WeakMap, WeakSet }.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.has\n // https://tc39.es/ecma262/#sec-weakset.prototype.has\n has: function has(key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).has(key);\n return data && hasOwn(data, state.id);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `WeakMap.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.get\n get: function get(key) {\n var state = getInternalState(this);\n if (isObject(key)) {\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).get(key);\n return data ? data[state.id] : undefined;\n }\n },\n // `WeakMap.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.set\n set: function set(key, value) {\n return define(this, key, value);\n }\n } : {\n // `WeakSet.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-weakset.prototype.add\n add: function add(value) {\n return define(this, value, true);\n }\n });\n\n return Constructor;\n }\n};\n","export enum ScrollDirection {\n SCROLL_NONE,\n SCROLL_BACKWARD,\n SCROLL_FORWARD,\n}\n\nexport enum Position {\n TOP,\n RIGHT,\n BOTTOM,\n LEFT,\n}\n\nexport const OPTIONS_DEFAULT_DOMAIN_TYPE = 'hour';\n\nexport const OPTIONS_DEFAULT_SUBDOMAIN_TYPE = 'minute';\nexport const OPTIONS_DEFAULT_SUBDOMAIN_WIDTH = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_GUTTER = 2;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_RADIUS = 0;\nexport const OPTIONS_DEFAULT_ANIMATION_DURATION = 200;\nexport const OPTIONS_DEFAULT_RANGE = 12;\nexport const OPTIONS_DEFAULT_ITEM_SELECTOR = '#cal-heatmap';\nexport const OPTIONS_DEFAULT_THEME = 'light';\nexport const OPTIONS_DEFAULT_LOCALE = 'en';\n\nexport const SCALE_BASE_OPACITY_COLOR = 'red';\nexport const SCALE_BASE_COLOR_SCHEME = 'YlOrBr';\nexport const SCALE_BASE_COLOR_TYPE = 'quantize';\nexport const SCALE_BASE_COLOR_DOMAIN = [0, 100];\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionWeak = require('../internals/collection-weak');\n\n// `WeakSet` constructor\n// https://tc39.es/ecma262/#sec-weakset-constructor\ncollection('WeakSet', function (init) {\n return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionWeak);\n","import { ScrollDirection } from '../constant';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type DomainCollection from './DomainCollection';\nimport type { Timestamp } from '../index';\n\nexport default class Navigator {\n calendar: CalHeatmap;\n\n minDomainReached: boolean;\n\n maxDomainReached: boolean;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.maxDomainReached = false;\n this.minDomainReached = false;\n }\n\n loadNewDomains(\n newDomainCollection: DomainCollection,\n direction: ScrollDirection = ScrollDirection.SCROLL_NONE,\n ): ScrollDirection {\n const { options } = this.calendar.options;\n const templatesClt = this.calendar.templateCollection;\n const minDate = options.date.min ?\n templatesClt.get(options.domain.type)!.extractUnit(+options.date.min) :\n undefined;\n const maxDate = options.date.max ?\n templatesClt.get(options.domain.type)!.extractUnit(+options.date.max) :\n undefined;\n const { domainCollection } = this.calendar;\n\n if (\n this.#isDomainBoundaryReached(\n newDomainCollection,\n minDate,\n maxDate,\n direction,\n )\n ) {\n return ScrollDirection.SCROLL_NONE;\n }\n\n if (direction !== ScrollDirection.SCROLL_NONE) {\n newDomainCollection\n .clamp(minDate, maxDate)\n .slice(options.range, direction === ScrollDirection.SCROLL_FORWARD);\n }\n\n domainCollection.merge(\n newDomainCollection,\n options.range,\n (domainKey: Timestamp, index: number) => {\n let subDomainEndDate = null;\n if (newDomainCollection.at(index + 1)) {\n subDomainEndDate = newDomainCollection.at(index + 1);\n } else {\n subDomainEndDate = this.calendar.dateHelper\n .intervals(options.domain.type, domainKey, 2)\n .pop();\n }\n return templatesClt\n .get(options.subDomain.type)!\n .mapping(domainKey, subDomainEndDate!)\n .map((d) => ({ ...d, v: options.data.defaultValue }));\n },\n );\n\n this.#setDomainsBoundaryReached(\n domainCollection.min,\n domainCollection.max,\n minDate,\n maxDate,\n );\n\n if (direction === ScrollDirection.SCROLL_BACKWARD) {\n this.calendar.eventEmitter.emit('domainsLoaded', [domainCollection.min]);\n } else if (direction === ScrollDirection.SCROLL_FORWARD) {\n this.calendar.eventEmitter.emit('domainsLoaded', [domainCollection.max]);\n }\n\n return direction;\n }\n\n jumpTo(date: Date, reset: boolean): ScrollDirection {\n const { domainCollection, options } = this.calendar;\n const minDate = new Date(domainCollection.min!);\n const maxDate = new Date(domainCollection.max!);\n\n if (date < minDate) {\n return this.loadNewDomains(\n this.calendar.createDomainCollection(date, minDate, false),\n ScrollDirection.SCROLL_BACKWARD,\n );\n }\n if (reset) {\n return this.loadNewDomains(\n this.calendar.createDomainCollection(date, options.options.range),\n minDate < date ?\n ScrollDirection.SCROLL_FORWARD :\n ScrollDirection.SCROLL_BACKWARD,\n );\n }\n\n if (date > maxDate) {\n return this.loadNewDomains(\n this.calendar.createDomainCollection(maxDate, date, false),\n ScrollDirection.SCROLL_FORWARD,\n );\n }\n\n return ScrollDirection.SCROLL_NONE;\n }\n\n #isDomainBoundaryReached(\n newDomainCollection: DomainCollection,\n minDate?: Timestamp,\n maxDate?: Timestamp,\n direction?: ScrollDirection,\n ): boolean {\n if (\n maxDate &&\n newDomainCollection.max! >= maxDate &&\n this.maxDomainReached &&\n direction === ScrollDirection.SCROLL_FORWARD\n ) {\n return true;\n }\n\n if (\n minDate &&\n newDomainCollection.min! <= minDate &&\n this.minDomainReached &&\n direction === ScrollDirection.SCROLL_BACKWARD\n ) {\n return true;\n }\n\n return false;\n }\n\n #setDomainsBoundaryReached(\n lowerBound: Timestamp,\n upperBound: Timestamp,\n min?: Timestamp,\n max?: Timestamp,\n ): void {\n if (min) {\n const reached = lowerBound <= min;\n this.calendar.eventEmitter.emit(\n reached ? 'minDateReached' : 'minDateNotReached',\n );\n this.minDomainReached = reached;\n }\n if (max) {\n const reached = upperBound >= max;\n this.calendar.eventEmitter.emit(\n reached ? 'maxDateReached' : 'maxDateNotReached',\n );\n this.maxDomainReached = reached;\n }\n }\n}\n","'use strict';\nvar $TypeError = TypeError;\nvar MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991\n\nmodule.exports = function (it) {\n if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');\n return it;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar isArray = require('../internals/is-array');\nvar isObject = require('../internals/is-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');\nvar createProperty = require('../internals/create-property');\nvar arraySpeciesCreate = require('../internals/array-species-create');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');\n\n// We can't use this feature detection in V8 since it causes\n// deoptimization and serious performance degradation\n// https://github.com/zloirock/core-js/issues/679\nvar IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {\n var array = [];\n array[IS_CONCAT_SPREADABLE] = false;\n return array.concat()[0] !== array;\n});\n\nvar isConcatSpreadable = function (O) {\n if (!isObject(O)) return false;\n var spreadable = O[IS_CONCAT_SPREADABLE];\n return spreadable !== undefined ? !!spreadable : isArray(O);\n};\n\nvar FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat');\n\n// `Array.prototype.concat` method\n// https://tc39.es/ecma262/#sec-array.prototype.concat\n// with adding support of @@isConcatSpreadable and @@species\n$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n concat: function concat(arg) {\n var O = toObject(this);\n var A = arraySpeciesCreate(O, 0);\n var n = 0;\n var i, k, length, len, E;\n for (i = -1, length = arguments.length; i < length; i++) {\n E = i === -1 ? O : arguments[i];\n if (isConcatSpreadable(E)) {\n len = lengthOfArrayLike(E);\n doesNotExceedSafeInteger(n + len);\n for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);\n } else {\n doesNotExceedSafeInteger(n + 1);\n createProperty(A, n++, E);\n }\n }\n A.length = n;\n return A;\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = function (METHOD_NAME, argument) {\n var method = [][METHOD_NAME];\n return !!method && fails(function () {\n // eslint-disable-next-line no-useless-call -- required for testing\n method.call(null, argument || function () { return 1; }, 1);\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar nativeJoin = uncurryThis([].join);\n\nvar ES3_STRINGS = IndexedObject !== Object;\nvar FORCED = ES3_STRINGS || !arrayMethodIsStrict('join', ',');\n\n// `Array.prototype.join` method\n// https://tc39.es/ecma262/#sec-array.prototype.join\n$({ target: 'Array', proto: true, forced: FORCED }, {\n join: function join(separator) {\n return nativeJoin(toIndexedObject(this), separator === undefined ? ',' : separator);\n }\n});\n","'use strict';\nvar create = require('../internals/object-create');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n index: create(null),\n first: undefined,\n last: undefined,\n size: 0\n });\n if (!DESCRIPTORS) that.size = 0;\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n var previous, index;\n // change existing entry\n if (entry) {\n entry.value = value;\n // create new entry\n } else {\n state.last = entry = {\n index: index = fastKey(key, true),\n key: key,\n value: value,\n previous: previous = state.last,\n next: undefined,\n removed: false\n };\n if (!state.first) state.first = entry;\n if (previous) previous.next = entry;\n if (DESCRIPTORS) state.size++;\n else that.size++;\n // add to index\n if (index !== 'F') state.index[index] = entry;\n } return that;\n };\n\n var getEntry = function (that, key) {\n var state = getInternalState(that);\n // fast case\n var index = fastKey(key);\n var entry;\n if (index !== 'F') return state.index[index];\n // frozen object case\n for (entry = state.first; entry; entry = entry.next) {\n if (entry.key === key) return entry;\n }\n };\n\n defineBuiltIns(Prototype, {\n // `{ Map, Set }.prototype.clear()` methods\n // https://tc39.es/ecma262/#sec-map.prototype.clear\n // https://tc39.es/ecma262/#sec-set.prototype.clear\n clear: function clear() {\n var that = this;\n var state = getInternalState(that);\n var data = state.index;\n var entry = state.first;\n while (entry) {\n entry.removed = true;\n if (entry.previous) entry.previous = entry.previous.next = undefined;\n delete data[entry.index];\n entry = entry.next;\n }\n state.first = state.last = undefined;\n if (DESCRIPTORS) state.size = 0;\n else that.size = 0;\n },\n // `{ Map, Set }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.delete\n // https://tc39.es/ecma262/#sec-set.prototype.delete\n 'delete': function (key) {\n var that = this;\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n if (entry) {\n var next = entry.next;\n var prev = entry.previous;\n delete state.index[entry.index];\n entry.removed = true;\n if (prev) prev.next = next;\n if (next) next.previous = prev;\n if (state.first === entry) state.first = next;\n if (state.last === entry) state.last = prev;\n if (DESCRIPTORS) state.size--;\n else that.size--;\n } return !!entry;\n },\n // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.foreach\n // https://tc39.es/ecma262/#sec-set.prototype.foreach\n forEach: function forEach(callbackfn /* , that = undefined */) {\n var state = getInternalState(this);\n var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n var entry;\n while (entry = entry ? entry.next : state.first) {\n boundFunction(entry.value, entry.key, this);\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n }\n },\n // `{ Map, Set}.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.has\n // https://tc39.es/ecma262/#sec-set.prototype.has\n has: function has(key) {\n return !!getEntry(this, key);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `Map.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-map.prototype.get\n get: function get(key) {\n var entry = getEntry(this, key);\n return entry && entry.value;\n },\n // `Map.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-map.prototype.set\n set: function set(key, value) {\n return define(this, key === 0 ? 0 : key, value);\n }\n } : {\n // `Set.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-set.prototype.add\n add: function add(value) {\n return define(this, value = value === 0 ? 0 : value, value);\n }\n });\n if (DESCRIPTORS) defineBuiltInAccessor(Prototype, 'size', {\n configurable: true,\n get: function () {\n return getInternalState(this).size;\n }\n });\n return Constructor;\n },\n setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {\n var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods\n // https://tc39.es/ecma262/#sec-map.prototype.entries\n // https://tc39.es/ecma262/#sec-map.prototype.keys\n // https://tc39.es/ecma262/#sec-map.prototype.values\n // https://tc39.es/ecma262/#sec-map.prototype-@@iterator\n // https://tc39.es/ecma262/#sec-set.prototype.entries\n // https://tc39.es/ecma262/#sec-set.prototype.keys\n // https://tc39.es/ecma262/#sec-set.prototype.values\n // https://tc39.es/ecma262/#sec-set.prototype-@@iterator\n defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {\n setInternalState(this, {\n type: ITERATOR_NAME,\n target: iterated,\n state: getInternalCollectionState(iterated),\n kind: kind,\n last: undefined\n });\n }, function () {\n var state = getInternalIteratorState(this);\n var kind = state.kind;\n var entry = state.last;\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n // get next entry\n if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n // or finish the iteration\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n // return step by kind\n if (kind === 'keys') return createIterResultObject(entry.key, false);\n if (kind === 'values') return createIterResultObject(entry.value, false);\n return createIterResultObject([entry.key, entry.value], false);\n }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n // `{ Map, Set }.prototype[@@species]` accessors\n // https://tc39.es/ecma262/#sec-get-map-@@species\n // https://tc39.es/ecma262/#sec-get-set-@@species\n setSpecies(CONSTRUCTOR_NAME);\n }\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.es/ecma262/#sec-map-objects\ncollection('Map', function (init) {\n return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","'use strict';\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (O, P) {\n if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));\n};\n","'use strict';\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar floor = Math.floor;\n\nvar mergeSort = function (array, comparefn) {\n var length = array.length;\n var middle = floor(length / 2);\n return length < 8 ? insertionSort(array, comparefn) : merge(\n array,\n mergeSort(arraySlice(array, 0, middle), comparefn),\n mergeSort(arraySlice(array, middle), comparefn),\n comparefn\n );\n};\n\nvar insertionSort = function (array, comparefn) {\n var length = array.length;\n var i = 1;\n var element, j;\n\n while (i < length) {\n j = i;\n element = array[i];\n while (j && comparefn(array[j - 1], element) > 0) {\n array[j] = array[--j];\n }\n if (j !== i++) array[j] = element;\n } return array;\n};\n\nvar merge = function (array, left, right, comparefn) {\n var llength = left.length;\n var rlength = right.length;\n var lindex = 0;\n var rindex = 0;\n\n while (lindex < llength || rindex < rlength) {\n array[lindex + rindex] = (lindex < llength && rindex < rlength)\n ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]\n : lindex < llength ? left[lindex++] : right[rindex++];\n } return array;\n};\n\nmodule.exports = mergeSort;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nvar firefox = userAgent.match(/firefox\\/(\\d+)/i);\n\nmodule.exports = !!firefox && +firefox[1];\n","'use strict';\nvar UA = require('../internals/engine-user-agent');\n\nmodule.exports = /MSIE|Trident/.test(UA);\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nvar webkit = userAgent.match(/AppleWebKit\\/(\\d+)\\./);\n\nmodule.exports = !!webkit && +webkit[1];\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar deletePropertyOrThrow = require('../internals/delete-property-or-throw');\nvar toString = require('../internals/to-string');\nvar fails = require('../internals/fails');\nvar internalSort = require('../internals/array-sort');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\nvar FF = require('../internals/engine-ff-version');\nvar IE_OR_EDGE = require('../internals/engine-is-ie-or-edge');\nvar V8 = require('../internals/engine-v8-version');\nvar WEBKIT = require('../internals/engine-webkit-version');\n\nvar test = [];\nvar nativeSort = uncurryThis(test.sort);\nvar push = uncurryThis(test.push);\n\n// IE8-\nvar FAILS_ON_UNDEFINED = fails(function () {\n test.sort(undefined);\n});\n// V8 bug\nvar FAILS_ON_NULL = fails(function () {\n test.sort(null);\n});\n// Old WebKit\nvar STRICT_METHOD = arrayMethodIsStrict('sort');\n\nvar STABLE_SORT = !fails(function () {\n // feature detection can be too slow, so check engines versions\n if (V8) return V8 < 70;\n if (FF && FF > 3) return;\n if (IE_OR_EDGE) return true;\n if (WEBKIT) return WEBKIT < 603;\n\n var result = '';\n var code, chr, value, index;\n\n // generate an array with more 512 elements (Chakra and old V8 fails only in this case)\n for (code = 65; code < 76; code++) {\n chr = String.fromCharCode(code);\n\n switch (code) {\n case 66: case 69: case 70: case 72: value = 3; break;\n case 68: case 71: value = 4; break;\n default: value = 2;\n }\n\n for (index = 0; index < 47; index++) {\n test.push({ k: chr + index, v: value });\n }\n }\n\n test.sort(function (a, b) { return b.v - a.v; });\n\n for (index = 0; index < test.length; index++) {\n chr = test[index].k.charAt(0);\n if (result.charAt(result.length - 1) !== chr) result += chr;\n }\n\n return result !== 'DGBEFHACIJK';\n});\n\nvar FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;\n\nvar getSortCompare = function (comparefn) {\n return function (x, y) {\n if (y === undefined) return -1;\n if (x === undefined) return 1;\n if (comparefn !== undefined) return +comparefn(x, y) || 0;\n return toString(x) > toString(y) ? 1 : -1;\n };\n};\n\n// `Array.prototype.sort` method\n// https://tc39.es/ecma262/#sec-array.prototype.sort\n$({ target: 'Array', proto: true, forced: FORCED }, {\n sort: function sort(comparefn) {\n if (comparefn !== undefined) aCallable(comparefn);\n\n var array = toObject(this);\n\n if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn);\n\n var items = [];\n var arrayLength = lengthOfArrayLike(array);\n var itemsLength, index;\n\n for (index = 0; index < arrayLength; index++) {\n if (index in array) push(items, array[index]);\n }\n\n internalSort(items, getSortCompare(comparefn));\n\n itemsLength = lengthOfArrayLike(items);\n index = 0;\n\n while (index < itemsLength) array[index] = items[index++];\n while (index < arrayLength) deletePropertyOrThrow(array, index++);\n\n return array;\n }\n});\n","'use strict';\nvar $forEach = require('../internals/array-iteration').forEach;\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar STRICT_METHOD = arrayMethodIsStrict('forEach');\n\n// `Array.prototype.forEach` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.foreach\nmodule.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {\n return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n// eslint-disable-next-line es/no-array-prototype-foreach -- safe\n} : [].forEach;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar forEach = require('../internals/array-for-each');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar handlePrototype = function (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {\n createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);\n } catch (error) {\n CollectionPrototype.forEach = forEach;\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n if (DOMIterables[COLLECTION_NAME]) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype);\n }\n}\n\nhandlePrototype(DOMTokenListPrototype);\n","import { Position } from '../constant';\nimport type { Padding } from '../options/Options';\n\nexport function isHorizontal(position: string): boolean {\n return position === 'left' || position === 'right';\n}\n\nexport function isVertical(position: string): boolean {\n return position === 'top' || position === 'bottom';\n}\n\nexport function horizontalPadding(padding: Padding): number {\n return padding[Position.LEFT] + padding[Position.RIGHT];\n}\n\nexport function verticalPadding(padding: Padding): number {\n return padding[Position.TOP] + padding[Position.BOTTOM];\n}\n","import { ScrollDirection } from '../constant';\nimport { horizontalPadding, verticalPadding } from '../helpers/PositionHelper';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type DomainPainter from './DomainPainter';\nimport type DomainCollection from '../calendar/DomainCollection';\nimport type { SubDomain, Dimensions, Timestamp } from '../index';\n\ntype SubDomainWithCoordinates = Required & {\n pre_x: number;\n pre_y: number;\n width: number;\n height: number;\n inner_width: number;\n inner_height: number;\n};\n\nexport default class DomainCoordinates {\n calendar: CalHeatmap;\n\n domainPainter: DomainPainter;\n\n collection: Map;\n\n scrollDirection: ScrollDirection;\n\n constructor(calendar: CalHeatmap, domainPainter: DomainPainter) {\n this.calendar = calendar;\n this.domainPainter = domainPainter;\n this.collection = new Map();\n this.scrollDirection = ScrollDirection.SCROLL_FORWARD;\n }\n\n get(domainKey: Timestamp): SubDomainWithCoordinates | undefined {\n return this.collection.get(domainKey);\n }\n\n update(collection: DomainCollection, scrollDirection: ScrollDirection) {\n const { verticalOrientation, domain } = this.calendar.options.options;\n\n this.scrollDirection = scrollDirection;\n const dimensions: Dimensions = {\n width: 0,\n height: 0,\n };\n let exitingTotal = 0;\n let scrollFactor =\n scrollDirection === ScrollDirection.SCROLL_FORWARD ? -1 : 1;\n const { keys } = collection;\n if (this.calendar.options.options.domain.sort === 'desc') {\n keys.reverse();\n scrollFactor *= -1;\n }\n\n collection.yankedDomains.forEach((domainKey: Timestamp) => {\n exitingTotal +=\n this.collection.get(domainKey)![\n verticalOrientation ? 'height' : 'width'\n ];\n });\n collection.yankedDomains.forEach((domainKey: Timestamp) => {\n const coor = this.collection.get(domainKey)!;\n this.collection.set(domainKey, {\n ...coor,\n x: verticalOrientation ? coor.x : coor.x + exitingTotal * scrollFactor,\n y: verticalOrientation ? coor.y + exitingTotal * scrollFactor : coor.y,\n });\n });\n\n keys.forEach((domainKey: Timestamp) => {\n const w = this.#getWidth(domainKey);\n const h = this.#getHeight(domainKey);\n if (verticalOrientation) {\n dimensions.height += h;\n dimensions.width = Math.max(w, dimensions.width);\n } else {\n dimensions.width += w;\n dimensions.height = Math.max(h, dimensions.height);\n }\n\n const x = dimensions.width - w;\n const y = dimensions.height - h;\n\n this.collection.set(domainKey, {\n ...this.collection.get(domainKey)!,\n x: verticalOrientation ? 0 : x,\n y: verticalOrientation ? y : 0,\n pre_x: verticalOrientation ? x : x - exitingTotal * scrollFactor,\n pre_y: verticalOrientation ? y - exitingTotal * scrollFactor : y,\n width: w,\n height: h,\n inner_width: w - (verticalOrientation ? 0 : domain.gutter),\n inner_height: h - (!verticalOrientation ? 0 : domain.gutter),\n });\n });\n\n return dimensions;\n }\n\n /**\n * Return the full width of the domain block\n * @param {number} d Domain start timestamp\n * @return {number} The full width of the domain,\n * including all padding and gutter\n * Used to compute the x position of the domains on the x axis\n */\n #getWidth(d: Timestamp): number {\n const {\n domain, subDomain, x, verticalOrientation,\n } =\n this.calendar.options.options;\n const columnsCount = this.calendar.templateCollection\n .get(subDomain.type)!\n .columnsCount(d);\n\n const subDomainWidth =\n (subDomain.width + subDomain.gutter) * columnsCount - subDomain.gutter;\n\n return (\n horizontalPadding(domain.padding) +\n x.domainHorizontalLabelWidth +\n (verticalOrientation ? 0 : domain.gutter) +\n subDomainWidth\n );\n }\n\n /**\n * Return the full height of the domain block\n * @param {number} d Domain start timestamp\n * @return {number} The full height of the domain,\n * including all paddings and gutter.\n * Used to compute the y position of the domains on the y axis\n */\n #getHeight(d: Timestamp): number {\n const {\n domain, subDomain, x, verticalOrientation,\n } =\n this.calendar.options.options;\n const rowsCount = this.calendar.templateCollection\n .get(subDomain.type)!\n .rowsCount(d);\n\n const subDomainHeight =\n (subDomain.height + subDomain.gutter) * rowsCount - subDomain.gutter;\n\n return (\n verticalPadding(domain.padding) +\n subDomainHeight +\n (verticalOrientation ? domain.gutter : 0) +\n x.domainVerticalLabelHeight\n );\n }\n}\n","import DomainCoordinates from './DomainCoordinates';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { ScrollDirection } from '../constant';\nimport type { Dimensions, Timestamp } from '../index';\n\nconst DEFAULT_SELECTOR = '.ch-domain';\n\nexport default class DomainPainter {\n calendar: CalHeatmap;\n\n coordinates: DomainCoordinates;\n\n root: any;\n\n dimensions: Dimensions;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.coordinates = new DomainCoordinates(calendar, this);\n this.root = null;\n\n // Dimensions of the internal area containing all the domains\n // Excluding all surrounding margins\n this.dimensions = {\n width: 0,\n height: 0,\n };\n }\n\n paint(scrollDirection: ScrollDirection, rootNode: any): Promise[] {\n const { animationDuration } = this.calendar.options.options;\n const t = rootNode.transition().duration(animationDuration);\n const coor = this.coordinates;\n\n this.dimensions = coor.update(\n this.calendar.domainCollection,\n scrollDirection,\n );\n\n const promises: Promise[] = [];\n\n this.root = rootNode\n .selectAll(DEFAULT_SELECTOR)\n .data(this.calendar.domainCollection.keys, (d: Timestamp) => d)\n .join(\n (enter: any) => enter\n .append('svg')\n .attr('x', (d: Timestamp) => coor.get(d)!.pre_x)\n .attr('y', (d: Timestamp) => coor.get(d)!.pre_y)\n .attr('width', (d: Timestamp) => coor.get(d)!.inner_width)\n .attr('height', (d: Timestamp) => coor.get(d)!.inner_height)\n .attr('class', (d: Timestamp) => this.#getClassName(d))\n .call((enterSelection: any) => enterSelection\n .append('rect')\n .attr('width', (d: Timestamp) => coor.get(d)!.inner_width)\n .attr('height', (d: Timestamp) => coor.get(d)!.inner_height)\n .attr('class', `${DEFAULT_SELECTOR.slice(1)}-bg`))\n .call((enterSelection: any) => promises.push(\n enterSelection\n .transition(t)\n .attr('x', (d: Timestamp) => coor.get(d)!.x)\n .attr('y', (d: Timestamp) => coor.get(d)!.y)\n .end(),\n )),\n (update: any) => update\n .call((updateSelection: any) => promises.push(\n updateSelection\n .transition(t)\n .attr('x', (d: Timestamp) => coor.get(d)!.x)\n .attr('y', (d: Timestamp) => coor.get(d)!.y)\n .attr('width', (d: Timestamp) => coor.get(d)!.inner_width)\n .attr('height', (d: Timestamp) => coor.get(d)!.inner_height)\n .end(),\n ))\n .call((updateSelection: any) => promises.push(\n updateSelection\n .selectAll(`${DEFAULT_SELECTOR}-bg`)\n .transition(t)\n .attr('width', (d: Timestamp) => coor.get(d)!.inner_width)\n .attr('height', (d: Timestamp) => coor.get(d)!.inner_height)\n .end(),\n )),\n (exit: any) => exit.call((exitSelection: any) => promises.push(\n exitSelection\n .transition(t)\n .attr('x', (d: Timestamp) => coor.get(d)!.x)\n .attr('y', (d: Timestamp) => coor.get(d)!.y)\n .remove()\n .end(),\n )),\n );\n\n return promises;\n }\n\n #getClassName(d: Timestamp): string {\n let classname = DEFAULT_SELECTOR.slice(1);\n const helper = this.calendar.dateHelper.date(d);\n\n switch (this.calendar.options.options.domain.type) {\n case 'hour':\n classname += ` h_${helper.hour()}`;\n break;\n case 'day':\n classname += ` d_${helper.date()} dy_${helper.format('d') + 1}`;\n break;\n case 'week':\n classname += ` w_${helper.week()}`;\n break;\n case 'month':\n classname += ` m_${helper.month() + 1}`;\n break;\n case 'year':\n classname += ` y_${helper.year()}`;\n break;\n default:\n }\n return classname;\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar $includes = require('../internals/array-includes').includes;\nvar fails = require('../internals/fails');\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// FF99+ bug\nvar BROKEN_ON_SPARSE = fails(function () {\n // eslint-disable-next-line es/no-array-prototype-includes -- detection\n return !Array(1).includes();\n});\n\n// `Array.prototype.includes` method\n// https://tc39.es/ecma262/#sec-array.prototype.includes\n$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {\n includes: function includes(el /* , fromIndex = 0 */) {\n return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('includes');\n","'use strict';\nvar $ = require('../internals/export');\nvar $filter = require('../internals/array-iteration').filter;\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter');\n\n// `Array.prototype.filter` method\n// https://tc39.es/ecma262/#sec-array.prototype.filter\n// with adding support of @@species\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n filter: function filter(callbackfn /* , thisArg */) {\n return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar iteratorClose = require('../internals/iterator-close');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n try {\n return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar toObject = require('../internals/to-object');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar isConstructor = require('../internals/is-constructor');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $Array = Array;\n\n// `Array.from` method implementation\n// https://tc39.es/ecma262/#sec-array.from\nmodule.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n var O = toObject(arrayLike);\n var IS_CONSTRUCTOR = isConstructor(this);\n var argumentsLength = arguments.length;\n var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n var mapping = mapfn !== undefined;\n if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);\n var iteratorMethod = getIteratorMethod(O);\n var index = 0;\n var length, result, step, iterator, next, value;\n // if the target is not iterable or it's an array with the default iterator - use a simple case\n if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) {\n iterator = getIterator(O, iteratorMethod);\n next = iterator.next;\n result = IS_CONSTRUCTOR ? new this() : [];\n for (;!(step = call(next, iterator)).done; index++) {\n value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;\n createProperty(result, index, value);\n }\n } else {\n length = lengthOfArrayLike(O);\n result = IS_CONSTRUCTOR ? new this(length) : $Array(length);\n for (;length > index; index++) {\n value = mapping ? mapfn(O[index], index) : O[index];\n createProperty(result, index, value);\n }\n }\n result.length = index;\n return result;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar from = require('../internals/array-from');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\n\nvar INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {\n // eslint-disable-next-line es/no-array-from -- required for testing\n Array.from(iterable);\n});\n\n// `Array.from` method\n// https://tc39.es/ecma262/#sec-array.from\n$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {\n from: from\n});\n","import castArray from 'lodash-es/castArray';\n\nimport type { SubDomain } from '../index';\nimport type {\n DataOptions,\n DataGroupType,\n DataRecord,\n} from '../options/Options';\nimport { DomainType, Timestamp } from '../index';\nimport type DateHelper from '../helpers/DateHelper';\n\nexport const DOMAIN_FORMAT: Record = {\n year: 'YYYY',\n month: 'MMMM',\n week: 'wo [week] YYYY',\n xDay: 'Do MMM',\n ghDay: 'Do MMM',\n day: 'Do MMM',\n hour: 'HH:00',\n minute: 'HH:mm',\n};\n\ntype GroupedRecords = Map;\ntype ValueType = string | number | null;\n\nexport default class DomainCollection {\n collection: Map;\n\n dateHelper: DateHelper;\n\n min: Timestamp;\n\n max: Timestamp;\n\n keys: Timestamp[];\n\n yankedDomains: Timestamp[];\n\n constructor(\n dateHelper: DateHelper,\n interval?: DomainType,\n start?: Date | Timestamp,\n range?: Date | Timestamp,\n excludeEnd: boolean = false,\n ) {\n this.collection = new Map();\n this.dateHelper = dateHelper;\n\n if (interval && start && range) {\n const ts = this.dateHelper\n .intervals(interval, start, range, excludeEnd)\n .map((d: Timestamp) => castArray(d));\n\n // @ts-ignore\n this.collection = new Map(ts);\n }\n\n this.min = 0;\n this.max = 0;\n this.keys = [];\n this.yankedDomains = [];\n\n if (this.collection.size > 0) {\n this.#refreshKeys();\n }\n }\n\n has(key: Timestamp): boolean {\n return this.collection.has(key);\n }\n\n get(key: Timestamp) {\n return this.collection.get(key);\n }\n\n forEach(callback: any) {\n return this.collection.forEach(callback);\n }\n\n at(index: number): Timestamp {\n return this.keys[index];\n }\n\n clamp(minDate?: Timestamp, maxDate?: Timestamp): DomainCollection {\n if (minDate && this.min! < minDate) {\n this.keys\n .filter((key) => key < minDate)\n .forEach((d) => this.collection.delete(d));\n }\n\n if (maxDate && this.max! > maxDate) {\n this.keys\n .filter((key) => key > maxDate)\n .forEach((d) => this.collection.delete(d));\n }\n\n this.#refreshKeys();\n\n return this;\n }\n\n merge(\n newCollection: DomainCollection,\n limit: number,\n createValueCallback: Function,\n ): void {\n this.yankedDomains = [];\n\n newCollection.keys.forEach((domainKey, index) => {\n if (this.has(domainKey)) {\n return;\n }\n\n if (this.collection.size >= limit) {\n let keyToRemove = this.max;\n\n if (domainKey > this.max!) {\n keyToRemove = this.min;\n }\n\n if (keyToRemove && this.collection.delete(keyToRemove)) {\n this.yankedDomains.push(keyToRemove);\n }\n }\n this.collection.set(domainKey, createValueCallback(domainKey, index));\n this.#refreshKeys();\n });\n this.yankedDomains = this.yankedDomains.sort((a, b) => a - b);\n }\n\n slice(limit: number = 0, fromBeginning: boolean = true): DomainCollection {\n if (this.keys.length > limit) {\n const keysToDelete = fromBeginning ?\n this.keys.slice(0, -limit) :\n this.keys.slice(limit);\n\n keysToDelete.forEach((key) => {\n this.collection.delete(key);\n });\n\n this.#refreshKeys();\n }\n\n return this;\n }\n\n fill(\n data: DataRecord[],\n {\n x,\n y,\n groupY,\n defaultValue,\n }: {\n x: DataOptions['x'];\n y: DataOptions['y'];\n groupY: DataOptions['groupY'];\n defaultValue: DataOptions['defaultValue'];\n },\n subDomainKeyExtractor: Function,\n ): void {\n const groupedRecords: GroupedRecords = this.groupRecords(\n data,\n x,\n subDomainKeyExtractor,\n );\n\n this.keys.forEach((domainKey) => {\n const records = groupedRecords.get(domainKey) || {};\n this.#setSubDomainValues(domainKey, records, y, groupY, defaultValue);\n });\n }\n\n #setSubDomainValues(\n domainKey: Timestamp,\n records: { [key: string]: DataRecord[] },\n y: DataOptions['y'],\n groupY: DataOptions['groupY'],\n defaultValue: DataOptions['defaultValue'],\n ): void {\n this.get(domainKey)!.forEach((subDomain: SubDomain, index: number) => {\n let value: ValueType = defaultValue;\n if (records.hasOwnProperty(subDomain.t)) {\n value = this.groupValues(\n this.#extractValues(records[subDomain.t], y),\n groupY,\n );\n }\n\n this.get(domainKey)![index].v = value;\n });\n }\n\n groupRecords(\n data: DataRecord[],\n x: DataOptions['x'],\n subDomainKeyExtractor: Function,\n ): GroupedRecords {\n const results: GroupedRecords = new Map();\n const validSubDomainTimestamp: Map = new Map();\n this.keys.forEach((domainKey) => {\n this.get(domainKey)!.forEach((subDomain: SubDomain) => {\n validSubDomainTimestamp.set(subDomain.t, domainKey);\n });\n });\n\n data.forEach((d) => {\n const timestamp = this.extractTimestamp(d, x, subDomainKeyExtractor);\n\n if (validSubDomainTimestamp.has(timestamp)) {\n const domainKey = validSubDomainTimestamp.get(timestamp)!;\n const records = results.get(domainKey) || {};\n records[timestamp] ||= [];\n records[timestamp].push(d);\n\n results.set(domainKey, records);\n }\n });\n\n return results;\n }\n\n // eslint-disable-next-line class-methods-use-this\n #extractValues(data: DataRecord[], y: string | Function): ValueType[] {\n return data.map((d): ValueType => (typeof y === 'function' ? y(d) : d[y]));\n }\n\n // eslint-disable-next-line class-methods-use-this\n groupValues(\n values: ValueType[],\n groupFn: DataGroupType | ((values: ValueType[]) => ValueType),\n ): ValueType {\n const cleanedValues = values.filter((n) => n !== null);\n\n if (typeof groupFn === 'string') {\n if (cleanedValues.every((n) => typeof n === 'number')) {\n switch (groupFn) {\n case 'sum':\n return (cleanedValues as number[]).reduce((a, b) => a + b, 0);\n case 'count':\n return cleanedValues.length;\n case 'min':\n return Math.min(...(cleanedValues as number[])) || null;\n case 'max':\n return Math.max(...(cleanedValues as number[])) || null;\n case 'average':\n return cleanedValues.length > 0 ?\n (cleanedValues as number[]).reduce((a, b) => a + b, 0) /\n cleanedValues.length :\n null;\n default:\n return null;\n }\n }\n\n switch (groupFn) {\n case 'count':\n return cleanedValues.length;\n default:\n return null;\n }\n } else if (typeof groupFn === 'function') {\n return groupFn(cleanedValues);\n }\n\n return null;\n }\n\n // eslint-disable-next-line class-methods-use-this\n extractTimestamp(\n datum: DataRecord,\n x: string | Function,\n extractorFn: Function,\n ): Timestamp {\n let timestamp: string | Timestamp =\n typeof x === 'function' ? x(datum) : datum[x];\n\n if (typeof timestamp === 'string') {\n timestamp = +new Date(timestamp);\n }\n\n return extractorFn(timestamp);\n }\n\n #refreshKeys(): Timestamp[] {\n this.keys = Array.from(this.collection.keys())\n .map((d: any) => parseInt(d, 10))\n .sort((a, b) => a - b);\n\n const { keys } = this;\n // eslint-disable-next-line prefer-destructuring\n this.min = keys[0];\n this.max = keys[keys.length - 1];\n\n return this.keys;\n }\n}\n","import { Position } from '../constant';\nimport {\n isVertical,\n verticalPadding,\n horizontalPadding,\n} from '../helpers/PositionHelper';\nimport { DOMAIN_FORMAT } from '../calendar/DomainCollection';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { Timestamp } from '../index';\n\nconst DEFAULT_SELECTOR = '.ch-domain-text';\n\nexport default class DomainLabelPainter {\n calendar: CalHeatmap;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n }\n\n paint(root: any): void {\n const { label, type } = this.calendar.options.options.domain;\n const { dateHelper } = this.calendar;\n let format = label.text;\n if (format === null || format === '') {\n return;\n }\n\n if (typeof format === 'undefined') {\n format = DOMAIN_FORMAT[type];\n }\n\n root\n .selectAll(DEFAULT_SELECTOR)\n .data(\n (d: Timestamp) => [d],\n (d: Timestamp) => d,\n )\n .join(\n (enter: any) => enter\n .append('text')\n .attr('class', DEFAULT_SELECTOR.slice(1))\n .attr('x', (d: Timestamp) => this.#getX(d))\n .attr('y', (d: Timestamp) => this.#getY(d))\n .attr('text-anchor', label.textAlign)\n .attr('dominant-baseline', () => this.#textVerticalAlign())\n .text((d: Timestamp, i: number, nodes: any[]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n dateHelper.format(d, format!, nodes[i]))\n .call((selection: any) => this.#domainRotate(selection)),\n (update: any) => {\n update\n .attr('x', (d: Timestamp) => this.#getX(d))\n .attr('y', (d: Timestamp) => this.#getY(d))\n .attr('text-anchor', label.textAlign)\n .attr('dominant-baseline', () => this.#textVerticalAlign())\n .text((d: Timestamp, i: number, nodes: any[]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n dateHelper.format(d, format!, nodes[i]))\n .call((selection: any) => this.#domainRotate(selection));\n },\n );\n }\n\n #textVerticalAlign(): string {\n const { position, rotate } = this.calendar.options.options.domain.label;\n\n if (isVertical(position)) {\n return 'middle';\n }\n\n if (\n (rotate === 'left' && position === 'left') ||\n (rotate === 'right' && position === 'right')\n ) {\n return 'bottom';\n }\n\n return 'hanging';\n }\n\n #getX(d: Timestamp): number {\n const {\n padding,\n label: { position, textAlign, offset },\n } = this.calendar.options.options.domain;\n const { domainHorizontalLabelWidth } = this.calendar.options.options.x;\n\n let x = padding[Position.LEFT];\n\n if (position === 'right') {\n x += this.#getDomainInsideWidth(d);\n }\n\n if (textAlign === 'middle') {\n if (['top', 'bottom'].includes(position)) {\n x += this.#getDomainInsideWidth(d) / 2;\n } else {\n x += domainHorizontalLabelWidth / 2;\n }\n }\n\n if (textAlign === 'end') {\n if (isVertical(position)) {\n x += this.#getDomainInsideWidth(d);\n } else {\n x += domainHorizontalLabelWidth;\n }\n }\n\n return x + offset.x;\n }\n\n #getY(d: Timestamp): number {\n const {\n domain: {\n label: { position, offset },\n padding,\n },\n x,\n } = this.calendar.options.options;\n\n let y = padding[Position.TOP] + x.domainVerticalLabelHeight / 2;\n\n if (position === 'bottom') {\n y += this.#getDomainInsideHeight(d);\n }\n\n return y + offset.y;\n }\n\n #getDomainInsideWidth(d: Timestamp): number {\n const {\n domain: { padding },\n x: { domainHorizontalLabelWidth },\n } = this.calendar.options.options;\n const { coordinates } =\n this.calendar.calendarPainter.domainsContainerPainter.domainPainter;\n\n return (\n coordinates.get(d)!.inner_width -\n domainHorizontalLabelWidth -\n horizontalPadding(padding)\n );\n }\n\n #getDomainInsideHeight(d: Timestamp): number {\n const {\n x: { domainVerticalLabelHeight },\n domain: { padding },\n } = this.calendar.options.options;\n const { coordinates } =\n this.calendar.calendarPainter.domainsContainerPainter.domainPainter;\n\n return (\n coordinates.get(d)!.inner_height -\n domainVerticalLabelHeight -\n verticalPadding(padding)\n );\n }\n\n #domainRotate(selection: any) {\n const {\n domain: {\n label: { rotate, textAlign, position },\n },\n x,\n } = this.calendar.options.options;\n const labelWidth = x.domainHorizontalLabelWidth;\n\n switch (rotate) {\n // Rotating the text clockwise\n case 'right':\n selection.attr('transform', (d: Timestamp) => {\n const domainWidth = this.#getDomainInsideWidth(d);\n const domainHeight = this.#getDomainInsideHeight(d);\n const s = [\n `rotate(90, ${position === 'right' ? domainWidth : labelWidth}, 0)`,\n ];\n\n switch (position) {\n case 'right':\n if (textAlign === 'middle') {\n s.push(`translate(${domainHeight / 2 - labelWidth / 2})`);\n } else if (textAlign === 'end') {\n s.push(`translate(${domainHeight - labelWidth})`);\n }\n break;\n case 'left':\n if (textAlign === 'start') {\n s.push(`translate(${labelWidth})`);\n } else if (textAlign === 'middle') {\n s.push(`translate(${labelWidth / 2 + domainHeight / 2})`);\n } else if (textAlign === 'end') {\n s.push(`translate(${domainHeight})`);\n }\n break;\n default:\n }\n\n return s.join(',');\n });\n break;\n // Rotating the text anticlockwise\n case 'left':\n selection.attr('transform', (d: Timestamp) => {\n const domainWidth = this.#getDomainInsideWidth(d);\n const domainHeight = this.#getDomainInsideHeight(d);\n const s = [\n `rotate(270, ${\n position === 'right' ? domainWidth : labelWidth\n }, 0)`,\n ];\n\n switch (position) {\n case 'right':\n if (textAlign === 'start') {\n s.push(`translate(-${domainHeight})`);\n } else if (textAlign === 'middle') {\n s.push(`translate(-${domainHeight / 2 + labelWidth / 2})`);\n } else if (textAlign === 'end') {\n s.push(`translate(-${labelWidth})`);\n }\n break;\n case 'left':\n if (textAlign === 'start') {\n s.push(`translate(${labelWidth - domainHeight})`);\n } else if (textAlign === 'middle') {\n s.push(`translate(${labelWidth / 2 - domainHeight / 2})`);\n }\n break;\n default:\n }\n\n return s.join(',');\n });\n break;\n default:\n }\n }\n}\n","'use strict';\n// a string of all valid unicode whitespaces\nmodule.exports = '\\u0009\\u000A\\u000B\\u000C\\u000D\\u0020\\u00A0\\u1680\\u2000\\u2001\\u2002' +\n '\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\nvar whitespaces = require('../internals/whitespaces');\n\nvar replace = uncurryThis(''.replace);\nvar ltrim = RegExp('^[' + whitespaces + ']+');\nvar rtrim = RegExp('(^|[^' + whitespaces + '])[' + whitespaces + ']+$');\n\n// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation\nvar createMethod = function (TYPE) {\n return function ($this) {\n var string = toString(requireObjectCoercible($this));\n if (TYPE & 1) string = replace(string, ltrim, '');\n if (TYPE & 2) string = replace(string, rtrim, '$1');\n return string;\n };\n};\n\nmodule.exports = {\n // `String.prototype.{ trimLeft, trimStart }` methods\n // https://tc39.es/ecma262/#sec-string.prototype.trimstart\n start: createMethod(1),\n // `String.prototype.{ trimRight, trimEnd }` methods\n // https://tc39.es/ecma262/#sec-string.prototype.trimend\n end: createMethod(2),\n // `String.prototype.trim` method\n // https://tc39.es/ecma262/#sec-string.prototype.trim\n trim: createMethod(3)\n};\n","'use strict';\nvar PROPER_FUNCTION_NAME = require('../internals/function-name').PROPER;\nvar fails = require('../internals/fails');\nvar whitespaces = require('../internals/whitespaces');\n\nvar non = '\\u200B\\u0085\\u180E';\n\n// check that a method works with the correct list\n// of whitespaces and has a correct name\nmodule.exports = function (METHOD_NAME) {\n return fails(function () {\n return !!whitespaces[METHOD_NAME]()\n || non[METHOD_NAME]() !== non\n || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME);\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $trim = require('../internals/string-trim').trim;\nvar forcedStringTrimMethod = require('../internals/string-trim-forced');\n\n// `String.prototype.trim` method\n// https://tc39.es/ecma262/#sec-string.prototype.trim\n$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {\n trim: function trim() {\n return $trim(this);\n }\n});\n","import { Position } from '../constant';\nimport type CalHeatmap from '../CalHeatmap';\nimport type { Timestamp, SubDomain } from '../index';\n\nexport const DEFAULT_SELECTOR = '.ch-subdomain';\nconst HIGHLIGHT_CLASSNAME = 'highlight';\n\nexport default class SubDomainPainter {\n calendar: CalHeatmap;\n\n root: any;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.root = null;\n }\n\n paint(root: any): void {\n this.root = root || this.root;\n const containerClassname = `${DEFAULT_SELECTOR}-container`;\n\n const subDomainSvgGroup = this.root\n .selectAll(containerClassname)\n .data(\n (d: Timestamp) => [d],\n (d: Timestamp) => d,\n )\n .join(\n (enter: any) => enter\n .append('svg')\n .call((selection: any) => this.#setPositions(selection))\n .attr('class', containerClassname.slice(1)),\n\n (update: any) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n update.call((selection: any) => this.#setPositions(selection)),\n );\n\n const {\n subDomain: {\n radius, width, height, sort,\n },\n } = this.calendar.options.options;\n const evt = this.calendar.eventEmitter;\n\n subDomainSvgGroup\n .selectAll('g')\n .data((d: Timestamp) => {\n const subDomainsCollection: SubDomain[] =\n this.calendar.domainCollection.get(d)!;\n if (sort === 'desc') {\n const max = Math.max(\n ...subDomainsCollection.map((s: SubDomain) => s.x),\n );\n subDomainsCollection.forEach((s: SubDomain, i: number) => {\n subDomainsCollection[i].x = Math.abs(s.x - max);\n });\n }\n\n return subDomainsCollection;\n })\n .join(\n (enter: any) => enter\n .append('g')\n .call((selection: any) => selection\n .insert('rect')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-bg`))\n .attr('width', width)\n .attr('height', height)\n .attr('x', (d: SubDomain) => this.#getX(d))\n .attr('y', (d: SubDomain) => this.#getY(d))\n .on('click', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('click', ev, d.t, d.v))\n .on('mouseover', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('mouseover', ev, d.t, d.v))\n .on('mouseout', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('mouseout', ev, d.t, d.v))\n .attr('rx', radius > 0 ? radius : null)\n .attr('ry', radius > 0 ? radius : null))\n .call((selection: any) => this.#appendText(selection)),\n (update: any) => update\n .selectAll('rect')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-bg`))\n .attr('width', width)\n .attr('height', height)\n .attr('x', (d: SubDomain) => this.#getX(d))\n .attr('y', (d: SubDomain) => this.#getY(d))\n .attr('rx', radius)\n .attr('ry', radius),\n );\n }\n\n /**\n * Set the subDomain group X and Y position\n * @param {d3-selection} selection A d3-selection object\n */\n #setPositions(selection: any): void {\n const { options } = this.calendar.options;\n const {\n padding,\n label: { position },\n } = options.domain;\n\n selection\n .attr('x', () => {\n let pos = padding[Position.LEFT];\n if (position === 'left') {\n pos += options.x.domainHorizontalLabelWidth;\n }\n return pos;\n })\n .attr('y', () => {\n let pos = padding[Position.TOP];\n if (position === 'top') {\n pos += options.x.domainVerticalLabelHeight;\n }\n return pos;\n });\n }\n\n /**\n * Return a classname if the specified date should be highlighted\n *\n * @param {number} timestamp Unix timestamp of the current subDomain\n * @return {String} the highlight class\n */\n #classname(timestamp: Timestamp, ...otherClasses: string[]): string {\n const {\n date: { highlight },\n subDomain: { type },\n } = this.calendar.options.options;\n let classname = '';\n\n if (highlight.length > 0) {\n highlight.forEach((d) => {\n const unitFn = this.calendar.templateCollection.get(type).extractUnit;\n\n if (unitFn(+d) === unitFn(timestamp)) {\n classname = HIGHLIGHT_CLASSNAME;\n }\n });\n }\n\n return [classname, ...otherClasses].join(' ').trim();\n }\n\n #appendText(elem: any) {\n const { width, height, label } = this.calendar.options.options.subDomain;\n\n if (!label) {\n return null;\n }\n\n return elem\n .append('text')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-text`))\n .attr('x', (d: SubDomain) => this.#getX(d) + width / 2)\n .attr('y', (d: SubDomain) => this.#getY(d) + height / 2)\n .attr('text-anchor', 'middle')\n .attr('dominant-baseline', 'central')\n .text((d: SubDomain, i: number, nodes: any[]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.calendar.dateHelper.format(d.t, label, d.v, nodes[i]));\n }\n\n #getCoordinates(axis: 'x' | 'y', d: SubDomain): number {\n const { subDomain } = this.calendar.options.options;\n return (\n d[axis] *\n (subDomain[axis === 'x' ? 'width' : 'height'] + subDomain.gutter)\n );\n }\n\n #getX(d: SubDomain): number {\n return this.#getCoordinates('x', d);\n }\n\n #getY(d: SubDomain): number {\n return this.#getCoordinates('y', d);\n }\n}\n","import { select } from 'd3-selection';\nimport DomainPainter from './DomainPainter';\nimport DomainLabelPainter from './DomainLabelPainter';\nimport SubDomainPainter from '../subDomain/SubDomainPainter';\nimport { ScrollDirection } from '../constant';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { Dimensions } from '../index';\n\nconst BASE_SELECTOR = '.ch-domain-container';\nconst TRANSITION_CLASSNAME = 'in-transition';\n\nclass DomainsContainerPainter {\n calendar: CalHeatmap;\n\n domainPainter: DomainPainter;\n\n domainLabelPainter: DomainLabelPainter;\n\n subDomainPainter: SubDomainPainter;\n\n dimensions: Dimensions;\n\n root: any;\n\n transitionsQueueCount: number;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n\n this.domainPainter = new DomainPainter(calendar);\n this.subDomainPainter = new SubDomainPainter(calendar);\n this.domainLabelPainter = new DomainLabelPainter(calendar);\n this.dimensions = {\n width: 0,\n height: 0,\n };\n this.transitionsQueueCount = 0;\n }\n\n setup() {\n this.root = this.calendar.calendarPainter.root\n .attr('x', 0)\n .attr('y', 0)\n .append('svg')\n .attr('class', BASE_SELECTOR.slice(1))\n .append('svg')\n .attr('class', `${BASE_SELECTOR.slice(1)}-animation-wrapper`);\n }\n\n paint(scrollDirection: ScrollDirection): Promise[] {\n this.#startAnimation();\n\n const result = this.domainPainter.paint(scrollDirection, this.root);\n this.subDomainPainter.paint(this.domainPainter.root);\n this.domainLabelPainter.paint(this.domainPainter.root);\n\n this.#recomputeDimensions();\n\n Promise.allSettled(result).then(() => {\n this.#endAnimation();\n });\n\n return result;\n }\n\n updatePosition() {\n if (!this.root?.node()) {\n return Promise.resolve();\n }\n\n const { animationDuration } = this.calendar.options.options;\n const topHeight = this.calendar.pluginManager.getHeightFromPosition('top');\n const leftWidth = this.calendar.pluginManager.getWidthFromPosition('left');\n\n return [\n select(this.root.node().parentNode)\n .transition()\n .duration(animationDuration)\n .call((selection: any) => {\n selection.attr('x', leftWidth).attr('y', topHeight);\n })\n .end(),\n ];\n }\n\n width(): Dimensions['width'] {\n return this.dimensions.width;\n }\n\n height(): Dimensions['height'] {\n return this.dimensions.height;\n }\n\n destroy(): Promise {\n this.#startAnimation();\n\n return Promise.resolve();\n }\n\n #startAnimation() {\n if (this.root?.node()) {\n this.transitionsQueueCount += 1;\n select(this.root.node().parentNode).classed(TRANSITION_CLASSNAME, true);\n }\n }\n\n #endAnimation() {\n if (this.root?.node()) {\n this.transitionsQueueCount -= 1;\n\n if (this.transitionsQueueCount === 0) {\n select(this.root.node().parentNode).classed(\n TRANSITION_CLASSNAME,\n false,\n );\n }\n }\n }\n\n #recomputeDimensions(): void {\n const {\n animationDuration,\n verticalOrientation,\n domain: { gutter },\n } = this.calendar.options.options;\n const { dimensions: domainsDimensions } = this.domainPainter;\n\n this.dimensions = {\n width: domainsDimensions.width - (verticalOrientation ? 0 : gutter),\n height: domainsDimensions.height - (!verticalOrientation ? 0 : gutter),\n };\n\n this.root\n .transition()\n .duration(animationDuration)\n .attr('width', this.dimensions.width)\n .attr('height', this.dimensions.height);\n }\n}\n\nexport default DomainsContainerPainter;\n","import type CalHeatmap from '../CalHeatmap';\n\nclass PluginPainter {\n calendar: CalHeatmap;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n }\n\n paint(): Promise[] {\n let promises: Promise[] = [];\n\n promises = promises.concat(this.calendar.pluginManager.paintAll());\n promises = promises.concat(this.setPluginsPosition());\n\n return promises;\n }\n\n setPluginsPosition(): Promise[] {\n const { pluginManager } = this.calendar;\n const { animationDuration } = this.calendar.options.options;\n const { domainsContainerPainter } = this.calendar.calendarPainter;\n\n const top = pluginManager.getFromPosition('top');\n const right = pluginManager.getFromPosition('right');\n const bottom = pluginManager.getFromPosition('bottom');\n const left = pluginManager.getFromPosition('left');\n\n const topHeight = pluginManager.getHeightFromPosition('top');\n const leftWidth = pluginManager.getWidthFromPosition('left');\n\n const promises: Promise[] = [];\n\n let topOffset = 0;\n top.forEach((plugin) => {\n promises.push(\n plugin.root\n .transition()\n .duration(animationDuration)\n .attr('y', topOffset)\n .attr('x', leftWidth)\n .end(),\n );\n topOffset += plugin.options.dimensions!.height;\n });\n\n let leftOffset = 0;\n left.forEach((plugin) => {\n promises.push(\n plugin.root\n .transition()\n .duration(animationDuration)\n .attr('x', leftOffset)\n .attr('y', topHeight)\n .end(),\n );\n leftOffset += plugin.options.dimensions!.width;\n });\n\n bottom.forEach((plugin) => {\n promises.push(\n plugin.root\n .transition()\n .duration(animationDuration)\n .attr('x', leftWidth)\n .attr('y', topHeight + domainsContainerPainter.height())\n .end(),\n );\n });\n\n leftOffset += domainsContainerPainter.width();\n\n right.forEach((plugin) => {\n promises.push(\n plugin.root\n .transition()\n .duration(animationDuration)\n .attr('x', leftOffset)\n .attr('y', topHeight)\n .end(),\n );\n leftOffset += plugin.options.dimensions!.width;\n });\n\n return promises;\n }\n\n insideWidth() {\n return (\n this.calendar.pluginManager.getWidthFromPosition('left') +\n this.calendar.pluginManager.getWidthFromPosition('right')\n );\n }\n\n insideHeight() {\n return (\n this.calendar.pluginManager.getHeightFromPosition('top') +\n this.calendar.pluginManager.getHeightFromPosition('bottom')\n );\n }\n}\n\nexport default PluginPainter;\n","import { select } from 'd3-selection';\n\nimport DomainsContainerPainter from '../domain/DomainsContainerPainter';\nimport PluginPainter from '../plugins/PluginPainter';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport { ScrollDirection } from '../constant';\nimport type { Dimensions } from '../index';\n\nexport const DEFAULT_SELECTOR = '.ch-container';\n\nexport default class CalendarPainter {\n calendar: CalHeatmap;\n\n dimensions: Dimensions;\n\n root: any;\n\n domainsContainerPainter: DomainsContainerPainter;\n\n pluginPainter: PluginPainter;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.dimensions = {\n width: 0,\n height: 0,\n };\n this.root = null;\n this.domainsContainerPainter = new DomainsContainerPainter(calendar);\n this.pluginPainter = new PluginPainter(calendar);\n }\n\n setup(): boolean {\n const { itemSelector, theme } = this.calendar.options.options;\n\n if (!this.root) {\n this.root = select(itemSelector)\n .append('svg')\n .attr('data-theme', theme)\n .attr('class', DEFAULT_SELECTOR.slice(1));\n this.domainsContainerPainter.setup();\n }\n\n this.calendar.pluginManager.setupAll();\n\n return true;\n }\n\n paint(navigationDir: ScrollDirection = ScrollDirection.SCROLL_NONE) {\n const transitions = this.domainsContainerPainter\n .paint(navigationDir)\n .concat(this.pluginPainter.paint())\n .concat(this.domainsContainerPainter.updatePosition());\n\n this.#resize();\n\n return Promise.allSettled(transitions);\n }\n\n #getHeight(): Dimensions['height'] {\n return (\n this.domainsContainerPainter.height() + this.pluginPainter.insideHeight()\n );\n }\n\n #getWidth(): Dimensions['width'] {\n return (\n this.domainsContainerPainter.width() + this.pluginPainter.insideWidth()\n );\n }\n\n #resize(): void {\n const { options } = this.calendar.options;\n\n const newWidth = this.#getWidth();\n const newHeight = this.#getHeight();\n\n this.root\n .transition()\n .duration(options.animationDuration)\n .attr('width', newWidth)\n .attr('height', newHeight);\n\n if (\n newWidth !== this.dimensions.width ||\n newHeight !== this.dimensions.height\n ) {\n this.calendar.eventEmitter.emit(\n 'resize',\n newWidth,\n newHeight,\n this.dimensions.width,\n this.dimensions.height,\n );\n }\n\n this.dimensions = {\n width: newWidth,\n height: newHeight,\n };\n }\n\n destroy(): Promise {\n const result: Promise[] = this.calendar.pluginManager\n .destroyAll()\n .concat(this.domainsContainerPainter.destroy());\n\n if (!this.root) {\n return Promise.allSettled(result);\n }\n\n result.push(\n this.root\n .transition()\n .duration(this.calendar.options.options.animationDuration)\n .attr('width', 0)\n .attr('height', 0)\n .remove()\n .end(),\n );\n\n return Promise.allSettled(result);\n }\n}\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nexport default root;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\nexport default getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\nexport default objectToString;\n","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\nexport default baseGetTag;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\nexport default isObject;\n","import baseGetTag from './_baseGetTag.js';\nimport isObject from './isObject.js';\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nexport default isFunction;\n","'use strict';\nvar $ = require('../internals/export');\nvar toObject = require('../internals/to-object');\nvar nativeKeys = require('../internals/object-keys');\nvar fails = require('../internals/fails');\n\nvar FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {\n keys: function keys(it) {\n return nativeKeys(toObject(it));\n }\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\n// `IsRegExp` abstract operation\n// https://tc39.es/ecma262/#sec-isregexp\nmodule.exports = function (it) {\n var isRegExp;\n return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) === 'RegExp');\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar toLength = require('../internals/to-length');\nvar toString = require('../internals/to-string');\nvar notARegExp = require('../internals/not-a-regexp');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');\nvar IS_PURE = require('../internals/is-pure');\n\n// eslint-disable-next-line es/no-string-prototype-startswith -- safe\nvar nativeStartsWith = uncurryThis(''.startsWith);\nvar stringSlice = uncurryThis(''.slice);\nvar min = Math.min;\n\nvar CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');\n// https://github.com/zloirock/core-js/pull/702\nvar MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {\n var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith');\n return descriptor && !descriptor.writable;\n}();\n\n// `String.prototype.startsWith` method\n// https://tc39.es/ecma262/#sec-string.prototype.startswith\n$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {\n startsWith: function startsWith(searchString /* , position = 0 */) {\n var that = toString(requireObjectCoercible(this));\n notARegExp(searchString);\n var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));\n var search = toString(searchString);\n return nativeStartsWith\n ? nativeStartsWith(that, search, index)\n : stringSlice(that, index, index + search.length) === search;\n }\n});\n","'use strict';\nvar isRegExp = require('../internals/is-regexp');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it) {\n if (isRegExp(it)) {\n throw new $TypeError(\"The method doesn't accept regular expressions\");\n } return it;\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\nmodule.exports = function (METHOD_NAME) {\n var regexp = /./;\n try {\n '/./'[METHOD_NAME](regexp);\n } catch (error1) {\n try {\n regexp[MATCH] = false;\n return '/./'[METHOD_NAME](regexp);\n } catch (error2) { /* empty */ }\n } return false;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar objectGetPrototypeOf = require('../internals/object-get-prototype-of');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\nvar propertyIsEnumerable = uncurryThis($propertyIsEnumerable);\nvar push = uncurryThis([].push);\n\n// in some IE versions, `propertyIsEnumerable` returns incorrect result on integer keys\n// of `null` prototype objects\nvar IE_BUG = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-create -- safe\n var O = Object.create(null);\n O[2] = 2;\n return !propertyIsEnumerable(O, 2);\n});\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n return function (it) {\n var O = toIndexedObject(it);\n var keys = objectKeys(O);\n var IE_WORKAROUND = IE_BUG && objectGetPrototypeOf(O) === null;\n var length = keys.length;\n var i = 0;\n var result = [];\n var key;\n while (length > i) {\n key = keys[i++];\n if (!DESCRIPTORS || (IE_WORKAROUND ? key in O : propertyIsEnumerable(O, key))) {\n push(result, TO_ENTRIES ? [key, O[key]] : O[key]);\n }\n }\n return result;\n };\n};\n\nmodule.exports = {\n // `Object.entries` method\n // https://tc39.es/ecma262/#sec-object.entries\n entries: createMethod(true),\n // `Object.values` method\n // https://tc39.es/ecma262/#sec-object.values\n values: createMethod(false)\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $entries = require('../internals/object-to-array').entries;\n\n// `Object.entries` method\n// https://tc39.es/ecma262/#sec-object.entries\n$({ target: 'Object', stat: true }, {\n entries: function entries(O) {\n return $entries(O);\n }\n});\n","import {ascending, descending} from \"d3\";\n\nexport function defined(x) {\n return x != null && !Number.isNaN(x);\n}\n\nexport function ascendingDefined(a, b) {\n return +defined(b) - +defined(a) || ascending(a, b);\n}\n\nexport function descendingDefined(a, b) {\n return +defined(b) - +defined(a) || descending(a, b);\n}\n\nexport function nonempty(x) {\n return x != null && `${x}` !== \"\";\n}\n\nexport function finite(x) {\n return isFinite(x) ? x : NaN;\n}\n\nexport function positive(x) {\n return x > 0 && isFinite(x) ? x : NaN;\n}\n\nexport function negative(x) {\n return x < 0 && isFinite(x) ? x : NaN;\n}\n","const re = /^(?:[-+]\\d{2})?\\d{4}(?:-\\d{2}(?:-\\d{2})?)?(?:T\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{3})?)?(?:Z|[-+]\\d{2}:?\\d{2})?)?$/;\n\nexport default function parse(string, fallback) {\n if (!re.test(string += \"\")) return typeof fallback === \"function\" ? fallback(string) : fallback;\n return new Date(string);\n}\n","import {utcSecond, utcMinute, utcHour, utcDay, utcWeek, utcMonth, utcYear} from \"d3\";\nimport {utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSunday} from \"d3\";\nimport {timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear} from \"d3\";\nimport {timeMonday, timeTuesday, timeWednesday, timeThursday, timeFriday, timeSaturday, timeSunday} from \"d3\";\n\nconst timeIntervals = new Map([\n [\"second\", timeSecond],\n [\"minute\", timeMinute],\n [\"hour\", timeHour],\n [\"day\", timeDay],\n [\"week\", timeWeek],\n [\"month\", timeMonth],\n [\"quarter\", timeMonth.every(3)],\n [\"half\", timeMonth.every(6)],\n [\"year\", timeYear],\n [\"monday\", timeMonday],\n [\"tuesday\", timeTuesday],\n [\"wednesday\", timeWednesday],\n [\"thursday\", timeThursday],\n [\"friday\", timeFriday],\n [\"saturday\", timeSaturday],\n [\"sunday\", timeSunday]\n]);\n\nconst utcIntervals = new Map([\n [\"second\", utcSecond],\n [\"minute\", utcMinute],\n [\"hour\", utcHour],\n [\"day\", utcDay],\n [\"week\", utcWeek],\n [\"month\", utcMonth],\n [\"quarter\", utcMonth.every(3)],\n [\"half\", utcMonth.every(6)],\n [\"year\", utcYear],\n [\"monday\", utcMonday],\n [\"tuesday\", utcTuesday],\n [\"wednesday\", utcWednesday],\n [\"thursday\", utcThursday],\n [\"friday\", utcFriday],\n [\"saturday\", utcSaturday],\n [\"sunday\", utcSunday]\n]);\n\nexport function maybeTimeInterval(interval) {\n const i = timeIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n\nexport function maybeUtcInterval(interval) {\n const i = utcIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n","import {parse as isoParse} from \"isoformat\";\nimport {color, descending, range as rangei, quantile} from \"d3\";\nimport {maybeTimeInterval, maybeUtcInterval} from \"./time.js\";\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\nexport const TypedArray = Object.getPrototypeOf(Uint8Array);\nconst objectToString = Object.prototype.toString;\n\nexport function valueof(data, value, type) {\n const valueType = typeof value;\n return valueType === \"string\"\n ? maybeTypedMap(data, field(value), type)\n : valueType === \"function\"\n ? maybeTypedMap(data, value, type)\n : valueType === \"number\" || value instanceof Date || valueType === \"boolean\"\n ? map(data, constant(value), type)\n : typeof value?.transform === \"function\"\n ? maybeTypedArrayify(value.transform(data), type)\n : maybeTypedArrayify(value, type);\n}\n\nfunction maybeTypedMap(data, f, type) {\n return map(data, type?.prototype instanceof TypedArray ? floater(f) : f, type);\n}\n\nfunction maybeTypedArrayify(data, type) {\n return type === undefined\n ? arrayify(data) // preserve undefined type\n : data instanceof type\n ? data\n : type.prototype instanceof TypedArray && !(data instanceof TypedArray)\n ? type.from(data, coerceNumber)\n : type.from(data);\n}\n\nfunction floater(f) {\n return (d, i) => coerceNumber(f(d, i));\n}\n\nexport const field = (name) => (d) => d[name];\nexport const indexOf = {transform: range};\nexport const identity = {transform: (d) => d};\nexport const zero = () => 0;\nexport const one = () => 1;\nexport const yes = () => true;\nexport const string = (x) => (x == null ? x : `${x}`);\nexport const number = (x) => (x == null ? x : +x);\nexport const boolean = (x) => (x == null ? x : !!x);\nexport const first = (x) => (x ? x[0] : undefined);\nexport const second = (x) => (x ? x[1] : undefined);\nexport const third = (x) => (x ? x[2] : undefined);\nexport const constant = (x) => () => x;\n\n// Converts a string like “p25” into a function that takes an index I and an\n// accessor function f, returning the corresponding percentile value.\nexport function percentile(reduce) {\n const p = +`${reduce}`.slice(1) / 100;\n return (I, f) => quantile(I, p, f);\n}\n\n// If the values are specified as a typed array, no coercion is required.\nexport function coerceNumbers(values) {\n return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array);\n}\n\n// Unlike Mark’s number, here we want to convert null and undefined to NaN since\n// the result will be stored in a Float64Array and we don’t want null to be\n// coerced to zero. We use Number instead of unary + to allow BigInt coercion.\nfunction coerceNumber(x) {\n return x == null ? NaN : Number(x);\n}\n\nexport function coerceDates(values) {\n return map(values, coerceDate);\n}\n\n// When coercing strings to dates, we only want to allow the ISO 8601 format\n// since the built-in string parsing of the Date constructor varies across\n// browsers. (In the future, this could be made more liberal if desired, though\n// it is still generally preferable to do date parsing yourself explicitly,\n// rather than rely on Plot.) Any non-string values are coerced to number first\n// and treated as milliseconds since UNIX epoch.\nexport function coerceDate(x) {\n return x instanceof Date && !isNaN(x)\n ? x\n : typeof x === \"string\"\n ? isoParse(x)\n : x == null || isNaN((x = +x))\n ? undefined\n : new Date(x);\n}\n\n// Some channels may allow a string constant to be specified; to differentiate\n// string constants (e.g., \"red\") from named fields (e.g., \"date\"), this\n// function tests whether the given value is a CSS color string and returns a\n// tuple [channel, constant] where one of the two is undefined, and the other is\n// the given value. If you wish to reference a named field that is also a valid\n// CSS color, use an accessor (d => d.red) instead.\nexport function maybeColorChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null ? [undefined, \"none\"] : isColor(value) ? [undefined, value] : [value, undefined];\n}\n\n// Similar to maybeColorChannel, this tests whether the given value is a number\n// indicating a constant, and otherwise assumes that it’s a channel value.\nexport function maybeNumberChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null || typeof value === \"number\" ? [undefined, value] : [value, undefined];\n}\n\n// Validates the specified optional string against the allowed list of keywords.\nexport function maybeKeyword(input, name, allowed) {\n if (input != null) return keyword(input, name, allowed);\n}\n\n// Validates the specified required string against the allowed list of keywords.\nexport function keyword(input, name, allowed) {\n const i = `${input}`.toLowerCase();\n if (!allowed.includes(i)) throw new Error(`invalid ${name}: ${input}`);\n return i;\n}\n\n// Promotes the specified data to an array as needed.\nexport function arrayify(data) {\n return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data);\n}\n\n// An optimization of type.from(values, f): if the given values are already an\n// instanceof the desired array type, the faster values.map method is used.\nexport function map(values, f, type = Array) {\n return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f);\n}\n\n// An optimization of type.from(values): if the given values are already an\n// instanceof the desired array type, the faster values.slice method is used.\nexport function slice(values, type = Array) {\n return values instanceof type ? values.slice() : type.from(values);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a primitive value.\nexport function isObject(option) {\n return option?.toString === objectToString;\n}\n\n// Disambiguates a scale options object (e.g., {color: {type: \"linear\"}}) from\n// some other option (e.g., {color: \"red\"}). When creating standalone legends,\n// this is used to test whether a scale is defined; this should be consistent\n// with inferScaleType when there are no channels associated with the scale, and\n// if this returns true, then normalizeScale must return non-null.\nexport function isScaleOptions(option) {\n return isObject(option) && (option.type !== undefined || option.domain !== undefined);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a channel value\n// definition expressed as a channel transform (e.g., {transform: …}).\nexport function isOptions(option) {\n return isObject(option) && typeof option.transform !== \"function\";\n}\n\n// Disambiguates a sort transform (e.g., {sort: \"date\"}) from a channel domain\n// sort definition (e.g., {sort: {y: \"x\"}}).\nexport function isDomainSort(sort) {\n return isOptions(sort) && sort.value === undefined && sort.channel === undefined;\n}\n\n// For marks specified either as [0, x] or [x1, x2], such as areas and bars.\nexport function maybeZero(x, x1, x2, x3 = identity) {\n if (x1 === undefined && x2 === undefined) {\n // {x} or {}\n (x1 = 0), (x2 = x === undefined ? x3 : x);\n } else if (x1 === undefined) {\n // {x, x2} or {x2}\n x1 = x === undefined ? 0 : x;\n } else if (x2 === undefined) {\n // {x, x1} or {x1}\n x2 = x === undefined ? 0 : x;\n }\n return [x1, x2];\n}\n\n// For marks that have x and y channels (e.g., cell, dot, line, text).\nexport function maybeTuple(x, y) {\n return x === undefined && y === undefined ? [first, second] : [x, y];\n}\n\n// A helper for extracting the z channel, if it is variable. Used by transforms\n// that require series, such as moving average and normalize.\nexport function maybeZ({z, fill, stroke} = {}) {\n if (z === undefined) [z] = maybeColorChannel(fill);\n if (z === undefined) [z] = maybeColorChannel(stroke);\n return z;\n}\n\n// Returns a Uint32Array with elements [0, 1, 2, … data.length - 1].\nexport function range(data) {\n const n = data.length;\n const r = new Uint32Array(n);\n for (let i = 0; i < n; ++i) r[i] = i;\n return r;\n}\n\n// Returns a filtered range of data given the test function.\nexport function where(data, test) {\n return range(data).filter((i) => test(data[i], i, data));\n}\n\n// Returns an array [values[index[0]], values[index[1]], …].\nexport function take(values, index) {\n return map(index, (i) => values[i]);\n}\n\n// Based on InternMap (d3.group).\nexport function keyof(value) {\n return value !== null && typeof value === \"object\" ? value.valueOf() : value;\n}\n\nexport function maybeInput(key, options) {\n if (options[key] !== undefined) return options[key];\n switch (key) {\n case \"x1\":\n case \"x2\":\n key = \"x\";\n break;\n case \"y1\":\n case \"y2\":\n key = \"y\";\n break;\n }\n return options[key];\n}\n\nexport function column(source) {\n // Defines a column whose values are lazily populated by calling the returned\n // setter. If the given source is labeled, the label is propagated to the\n // returned column definition.\n let value;\n return [\n {\n transform: () => value,\n label: labelof(source)\n },\n (v) => (value = v)\n ];\n}\n\n// Like column, but allows the source to be null.\nexport function maybeColumn(source) {\n return source == null ? [source] : column(source);\n}\n\nexport function labelof(value, defaultValue) {\n return typeof value === \"string\" ? value : value && value.label !== undefined ? value.label : defaultValue;\n}\n\n// Assuming that both x1 and x2 and lazy columns (per above), this derives a new\n// a column that’s the average of the two, and which inherits the column label\n// (if any). Both input columns are assumed to be quantitative. If either column\n// is temporal, the returned column is also temporal.\nexport function mid(x1, x2) {\n return {\n transform(data) {\n const X1 = x1.transform(data);\n const X2 = x2.transform(data);\n return isTemporal(X1) || isTemporal(X2)\n ? map(X1, (_, i) => new Date((+X1[i] + +X2[i]) / 2))\n : map(X1, (_, i) => (+X1[i] + +X2[i]) / 2, Float64Array);\n },\n label: x1.label\n };\n}\n\n// If interval is not nullish, converts interval shorthand such as a number (for\n// multiples) or a time interval name (such as “day”) to a {floor, offset,\n// range} object similar to a D3 time interval.\nexport function maybeInterval(interval, type) {\n if (interval == null) return;\n if (typeof interval === \"number\") {\n if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval;\n const n = Math.abs(interval);\n return interval < 0\n ? {\n floor: (d) => Math.floor(d * n) / n,\n offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo * n), hi * n).map((x) => x / n)\n }\n : {\n floor: (d) => Math.floor(d / n) * n,\n offset: (d) => d + n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo / n), hi / n).map((x) => x * n)\n };\n }\n if (typeof interval === \"string\") return (type === \"time\" ? maybeTimeInterval : maybeUtcInterval)(interval);\n if (typeof interval.floor !== \"function\") throw new Error(\"invalid interval; missing floor method\");\n if (typeof interval.offset !== \"function\") throw new Error(\"invalid interval; missing offset method\");\n return interval;\n}\n\n// Like maybeInterval, but requires a range method too.\nexport function maybeRangeInterval(interval, type) {\n interval = maybeInterval(interval, type);\n if (interval && typeof interval.range !== \"function\") throw new Error(\"invalid interval: missing range method\");\n return interval;\n}\n\n// Like maybeRangeInterval, but requires a ceil method too.\nexport function maybeNiceInterval(interval, type) {\n interval = maybeRangeInterval(interval, type);\n if (interval && typeof interval.ceil !== \"function\") throw new Error(\"invalid interval: missing ceil method\");\n return interval;\n}\n\n// This distinguishes between per-dimension options and a standalone value.\nexport function maybeValue(value) {\n return value === undefined || isOptions(value) ? value : {value};\n}\n\n// Coerces the given channel values (if any) to numbers. This is useful when\n// values will be interpolated into other code, such as an SVG transform, and\n// where we don’t wish to allow unexpected behavior for weird input.\nexport function numberChannel(source) {\n return source == null\n ? null\n : {\n transform: (data) => valueof(data, source, Float64Array),\n label: labelof(source)\n };\n}\n\nexport function isTuples(data) {\n if (!isIterable(data)) return false;\n for (const d of data) {\n if (d == null) continue;\n return typeof d === \"object\" && \"0\" in d && \"1\" in d;\n }\n}\n\nexport function isIterable(value) {\n return value && typeof value[Symbol.iterator] === \"function\";\n}\n\nexport function isTextual(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value !== \"object\" || value instanceof Date;\n }\n}\n\nexport function isOrdinal(values) {\n for (const value of values) {\n if (value == null) continue;\n const type = typeof value;\n return type === \"string\" || type === \"boolean\";\n }\n}\n\nexport function isTemporal(values) {\n for (const value of values) {\n if (value == null) continue;\n return value instanceof Date;\n }\n}\n\n// Are these strings that might represent dates? This is stricter than ISO 8601\n// because we want to ignore false positives on numbers; for example, the string\n// \"1192\" is more likely to represent a number than a date even though it is\n// valid ISO 8601 representing 1192-01-01.\nexport function isTemporalString(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"string\" && isNaN(value) && isoParse(value);\n }\n}\n\n// Are these strings that might represent numbers? This is stricter than\n// coercion because we want to ignore false positives on e.g. empty strings.\nexport function isNumericString(values) {\n for (const value of values) {\n if (value == null) continue;\n if (typeof value !== \"string\") return false;\n if (!value.trim()) continue;\n return !isNaN(value);\n }\n}\n\nexport function isNumeric(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"number\";\n }\n}\n\n// Returns true if every non-null value in the specified iterable of values\n// passes the specified predicate, and there is at least one non-null value;\n// returns false if at least one non-null value does not pass the specified\n// predicate; otherwise returns undefined (as if all values are null).\nexport function isEvery(values, is) {\n let every;\n for (const value of values) {\n if (value == null) continue;\n if (!is(value)) return false;\n every = true;\n }\n return every;\n}\n\n// Mostly relies on d3-color, with a few extra color keywords. Currently this\n// strictly requires that the value be a string; we might want to apply string\n// coercion here, though note that d3-color instances would need to support\n// valueOf to work correctly with InternMap.\n// https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint\nexport function isColor(value) {\n if (typeof value !== \"string\") return false;\n value = value.toLowerCase().trim();\n return (\n value === \"none\" ||\n value === \"currentcolor\" ||\n (value.startsWith(\"url(\") && value.endsWith(\")\")) || // , e.g. pattern or gradient\n (value.startsWith(\"var(\") && value.endsWith(\")\")) || // CSS variable\n color(value) !== null\n );\n}\n\nexport function isOpacity(value) {\n return typeof value === \"number\" && ((0 <= value && value <= 1) || isNaN(value));\n}\n\nexport function isNoneish(value) {\n return value == null || isNone(value);\n}\n\nexport function isNone(value) {\n return /^\\s*none\\s*$/i.test(value);\n}\n\nexport function isRound(value) {\n return /^\\s*round\\s*$/i.test(value);\n}\n\nexport function maybeFrameAnchor(value = \"middle\") {\n return keyword(value, \"frameAnchor\", [\n \"middle\",\n \"top-left\",\n \"top\",\n \"top-right\",\n \"right\",\n \"bottom-right\",\n \"bottom\",\n \"bottom-left\",\n \"left\"\n ]);\n}\n\n// Like a sort comparator, returns a positive value if the given array of values\n// is in ascending order, a negative value if the values are in descending\n// order. Assumes monotonicity; only tests the first and last values.\nexport function orderof(values) {\n if (values == null) return;\n const first = values[0];\n const last = values[values.length - 1];\n return descending(first, last);\n}\n\n// Unlike {...defaults, ...options}, this ensures that any undefined (but\n// present) properties in options inherit the given default value.\nexport function inherit(options = {}, ...rest) {\n let o = options;\n for (const defaults of rest) {\n for (const key in defaults) {\n if (o[key] === undefined) {\n const value = defaults[key];\n if (o === options) o = {...o, [key]: value};\n else o[key] = value;\n }\n }\n }\n return o;\n}\n\n// Given an iterable of named things (objects with a name property), returns a\n// corresponding object with properties associated with the given name.\nexport function named(things) {\n console.warn(\"named iterables are deprecated; please use an object instead\");\n const names = new Set();\n return Object.fromEntries(\n Array.from(things, (thing) => {\n const {name} = thing;\n if (name == null) throw new Error(\"missing name\");\n const key = `${name}`;\n if (key === \"__proto__\") throw new Error(`illegal name: ${key}`);\n if (names.has(key)) throw new Error(`duplicate name: ${key}`);\n names.add(key);\n return [name, thing];\n })\n );\n}\n\nexport function maybeNamed(things) {\n return isIterable(things) ? named(things) : things;\n}\n","// Positional scales have associated axes, and for ordinal data, a point or band\n// scale is used instead of an ordinal scale.\nexport const position = Symbol(\"position\");\n\n// Color scales default to the turbo interpolator for quantitative data, and to\n// the Tableau10 scheme for ordinal data. Color scales may also have an\n// associated legend.\nexport const color = Symbol(\"color\");\n\n// Radius scales default to the sqrt type, have a default range of [0, 3], and a\n// default domain from 0 to the median first quartile of associated channels.\nexport const radius = Symbol(\"radius\");\n\n// Length scales default to the linear type, have a default range of [0, 12],\n// and a default domain from 0 to the median median of associated channels.\nexport const length = Symbol(\"length\");\n\n// Opacity scales have a default range of [0, 1], and a default domain from 0 to\n// the maximum value of associated channels.\nexport const opacity = Symbol(\"opacity\");\n\n// Symbol scales have a default range of categorical symbols.\nexport const symbol = Symbol(\"symbol\");\n\n// TODO Rather than hard-coding the list of known scale names, collect the names\n// and categories for each plot specification, so that custom marks can register\n// custom scales.\nexport const registry = new Map([\n [\"x\", position],\n [\"y\", position],\n [\"fx\", position],\n [\"fy\", position],\n [\"r\", radius],\n [\"color\", color],\n [\"opacity\", opacity],\n [\"symbol\", symbol],\n [\"length\", length]\n]);\n","import {symbolAsterisk, symbolDiamond2, symbolPlus, symbolSquare2, symbolTriangle2, symbolTimes} from \"d3\";\nimport {symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye} from \"d3\";\n\nexport const sqrt3 = Math.sqrt(3);\nexport const sqrt4_3 = 2 / sqrt3;\n\nconst symbolHexagon = {\n draw(context, size) {\n const rx = Math.sqrt(size / Math.PI),\n ry = rx * sqrt4_3,\n hy = ry / 2;\n context.moveTo(0, ry);\n context.lineTo(rx, hy);\n context.lineTo(rx, -hy);\n context.lineTo(0, -ry);\n context.lineTo(-rx, -hy);\n context.lineTo(-rx, hy);\n context.closePath();\n }\n};\n\nconst symbols = new Map([\n [\"asterisk\", symbolAsterisk],\n [\"circle\", symbolCircle],\n [\"cross\", symbolCross],\n [\"diamond\", symbolDiamond],\n [\"diamond2\", symbolDiamond2],\n [\"hexagon\", symbolHexagon],\n [\"plus\", symbolPlus],\n [\"square\", symbolSquare],\n [\"square2\", symbolSquare2],\n [\"star\", symbolStar],\n [\"times\", symbolTimes],\n [\"triangle\", symbolTriangle],\n [\"triangle2\", symbolTriangle2],\n [\"wye\", symbolWye]\n]);\n\nfunction isSymbolObject(value) {\n return value && typeof value.draw === \"function\";\n}\n\nexport function isSymbol(value) {\n if (isSymbolObject(value)) return true;\n if (typeof value !== \"string\") return false;\n return symbols.has(value.toLowerCase());\n}\n\nexport function maybeSymbol(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return symbol;\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return value;\n throw new Error(`invalid symbol: ${symbol}`);\n}\n\nexport function maybeSymbolChannel(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return [undefined, symbol];\n if (typeof symbol === \"string\") {\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return [undefined, value];\n }\n return [symbol, undefined];\n}\n","let warnings = 0;\n\nexport function consumeWarnings() {\n const w = warnings;\n warnings = 0;\n return w;\n}\n\nexport function warn(message) {\n console.warn(message);\n ++warnings;\n}\n","import {\n interpolateBlues,\n interpolateBrBG,\n interpolateBuGn,\n interpolateBuPu,\n interpolateGnBu,\n interpolateGreens,\n interpolateGreys,\n interpolateOranges,\n interpolateOrRd,\n interpolatePiYG,\n interpolatePRGn,\n interpolatePuBu,\n interpolatePuBuGn,\n interpolatePuOr,\n interpolatePuRd,\n interpolatePurples,\n interpolateRdBu,\n interpolateRdGy,\n interpolateRdPu,\n interpolateRdYlBu,\n interpolateRdYlGn,\n interpolateReds,\n interpolateSpectral,\n interpolateYlGn,\n interpolateYlGnBu,\n interpolateYlOrBr,\n interpolateYlOrRd,\n interpolateTurbo,\n interpolateViridis,\n interpolateMagma,\n interpolateInferno,\n interpolatePlasma,\n interpolateCividis,\n interpolateCubehelixDefault,\n interpolateWarm,\n interpolateCool,\n interpolateRainbow,\n interpolateSinebow,\n quantize,\n schemeAccent,\n schemeBlues,\n schemeBrBG,\n schemeBuGn,\n schemeBuPu,\n schemeCategory10,\n schemeDark2,\n schemeGnBu,\n schemeGreens,\n schemeGreys,\n schemeOranges,\n schemeOrRd,\n schemePaired,\n schemePastel1,\n schemePastel2,\n schemePiYG,\n schemePRGn,\n schemePuBu,\n schemePuBuGn,\n schemePuOr,\n schemePuRd,\n schemePurples,\n schemeRdBu,\n schemeRdGy,\n schemeRdPu,\n schemeRdYlBu,\n schemeRdYlGn,\n schemeReds,\n schemeSet1,\n schemeSet2,\n schemeSet3,\n schemeSpectral,\n schemeTableau10,\n schemeYlGn,\n schemeYlGnBu,\n schemeYlOrBr,\n schemeYlOrRd\n} from \"d3\";\n\nconst ordinalSchemes = new Map([\n // categorical\n [\"accent\", schemeAccent],\n [\"category10\", schemeCategory10],\n [\"dark2\", schemeDark2],\n [\"paired\", schemePaired],\n [\"pastel1\", schemePastel1],\n [\"pastel2\", schemePastel2],\n [\"set1\", schemeSet1],\n [\"set2\", schemeSet2],\n [\"set3\", schemeSet3],\n [\"tableau10\", schemeTableau10],\n\n // diverging\n [\"brbg\", scheme11(schemeBrBG, interpolateBrBG)],\n [\"prgn\", scheme11(schemePRGn, interpolatePRGn)],\n [\"piyg\", scheme11(schemePiYG, interpolatePiYG)],\n [\"puor\", scheme11(schemePuOr, interpolatePuOr)],\n [\"rdbu\", scheme11(schemeRdBu, interpolateRdBu)],\n [\"rdgy\", scheme11(schemeRdGy, interpolateRdGy)],\n [\"rdylbu\", scheme11(schemeRdYlBu, interpolateRdYlBu)],\n [\"rdylgn\", scheme11(schemeRdYlGn, interpolateRdYlGn)],\n [\"spectral\", scheme11(schemeSpectral, interpolateSpectral)],\n\n // reversed diverging (for temperature data)\n [\"burd\", scheme11r(schemeRdBu, interpolateRdBu)],\n [\"buylrd\", scheme11r(schemeRdYlBu, interpolateRdYlBu)],\n\n // sequential (single-hue)\n [\"blues\", scheme9(schemeBlues, interpolateBlues)],\n [\"greens\", scheme9(schemeGreens, interpolateGreens)],\n [\"greys\", scheme9(schemeGreys, interpolateGreys)],\n [\"oranges\", scheme9(schemeOranges, interpolateOranges)],\n [\"purples\", scheme9(schemePurples, interpolatePurples)],\n [\"reds\", scheme9(schemeReds, interpolateReds)],\n\n // sequential (multi-hue)\n [\"turbo\", schemei(interpolateTurbo)],\n [\"viridis\", schemei(interpolateViridis)],\n [\"magma\", schemei(interpolateMagma)],\n [\"inferno\", schemei(interpolateInferno)],\n [\"plasma\", schemei(interpolatePlasma)],\n [\"cividis\", schemei(interpolateCividis)],\n [\"cubehelix\", schemei(interpolateCubehelixDefault)],\n [\"warm\", schemei(interpolateWarm)],\n [\"cool\", schemei(interpolateCool)],\n [\"bugn\", scheme9(schemeBuGn, interpolateBuGn)],\n [\"bupu\", scheme9(schemeBuPu, interpolateBuPu)],\n [\"gnbu\", scheme9(schemeGnBu, interpolateGnBu)],\n [\"orrd\", scheme9(schemeOrRd, interpolateOrRd)],\n [\"pubu\", scheme9(schemePuBu, interpolatePuBu)],\n [\"pubugn\", scheme9(schemePuBuGn, interpolatePuBuGn)],\n [\"purd\", scheme9(schemePuRd, interpolatePuRd)],\n [\"rdpu\", scheme9(schemeRdPu, interpolateRdPu)],\n [\"ylgn\", scheme9(schemeYlGn, interpolateYlGn)],\n [\"ylgnbu\", scheme9(schemeYlGnBu, interpolateYlGnBu)],\n [\"ylorbr\", scheme9(schemeYlOrBr, interpolateYlOrBr)],\n [\"ylorrd\", scheme9(schemeYlOrRd, interpolateYlOrRd)],\n\n // cyclical\n [\"rainbow\", schemeicyclical(interpolateRainbow)],\n [\"sinebow\", schemeicyclical(interpolateSinebow)]\n]);\n\nfunction scheme9(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 1) return [scheme[3][1]]; // favor midpoint\n if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker\n n = Math.max(3, Math.floor(n));\n return n > 9 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11r(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse();\n };\n}\n\nfunction schemei(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.max(2, Math.floor(n)));\n}\n\nfunction schemeicyclical(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.floor(n) + 1).slice(0, -1);\n}\n\nexport function ordinalScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`);\n return ordinalSchemes.get(s);\n}\n\nexport function ordinalRange(scheme, length) {\n const s = ordinalScheme(scheme);\n const r = typeof s === \"function\" ? s({length}) : s;\n return r.length !== length ? r.slice(0, length) : r;\n}\n\n// If the specified domain contains only booleans (ignoring null and undefined),\n// returns a corresponding range where false is mapped to the low color and true\n// is mapped to the high color of the specified scheme.\nexport function maybeBooleanRange(domain, scheme = \"greys\") {\n const range = new Set();\n const [f, t] = ordinalRange(scheme, 2);\n for (const value of domain) {\n if (value == null) continue;\n if (value === true) range.add(t);\n else if (value === false) range.add(f);\n else return;\n }\n return [...range];\n}\n\nconst quantitativeSchemes = new Map([\n // diverging\n [\"brbg\", interpolateBrBG],\n [\"prgn\", interpolatePRGn],\n [\"piyg\", interpolatePiYG],\n [\"puor\", interpolatePuOr],\n [\"rdbu\", interpolateRdBu],\n [\"rdgy\", interpolateRdGy],\n [\"rdylbu\", interpolateRdYlBu],\n [\"rdylgn\", interpolateRdYlGn],\n [\"spectral\", interpolateSpectral],\n\n // reversed diverging (for temperature data)\n [\"burd\", (t) => interpolateRdBu(1 - t)],\n [\"buylrd\", (t) => interpolateRdYlBu(1 - t)],\n\n // sequential (single-hue)\n [\"blues\", interpolateBlues],\n [\"greens\", interpolateGreens],\n [\"greys\", interpolateGreys],\n [\"purples\", interpolatePurples],\n [\"reds\", interpolateReds],\n [\"oranges\", interpolateOranges],\n\n // sequential (multi-hue)\n [\"turbo\", interpolateTurbo],\n [\"viridis\", interpolateViridis],\n [\"magma\", interpolateMagma],\n [\"inferno\", interpolateInferno],\n [\"plasma\", interpolatePlasma],\n [\"cividis\", interpolateCividis],\n [\"cubehelix\", interpolateCubehelixDefault],\n [\"warm\", interpolateWarm],\n [\"cool\", interpolateCool],\n [\"bugn\", interpolateBuGn],\n [\"bupu\", interpolateBuPu],\n [\"gnbu\", interpolateGnBu],\n [\"orrd\", interpolateOrRd],\n [\"pubugn\", interpolatePuBuGn],\n [\"pubu\", interpolatePuBu],\n [\"purd\", interpolatePuRd],\n [\"rdpu\", interpolateRdPu],\n [\"ylgnbu\", interpolateYlGnBu],\n [\"ylgn\", interpolateYlGn],\n [\"ylorbr\", interpolateYlOrBr],\n [\"ylorrd\", interpolateYlOrRd],\n\n // cyclical\n [\"rainbow\", interpolateRainbow],\n [\"sinebow\", interpolateSinebow]\n]);\n\nexport function quantitativeScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`);\n return quantitativeSchemes.get(s);\n}\n\nconst divergingSchemes = new Set([\n \"brbg\",\n \"prgn\",\n \"piyg\",\n \"puor\",\n \"rdbu\",\n \"rdgy\",\n \"rdylbu\",\n \"rdylgn\",\n \"spectral\",\n \"burd\",\n \"buylrd\"\n]);\n\nexport function isDivergingScheme(scheme) {\n return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase());\n}\n","import {\n descending,\n extent,\n interpolateHcl,\n interpolateHsl,\n interpolateLab,\n interpolateNumber,\n interpolateRgb,\n interpolateRound,\n min,\n max,\n median,\n quantile,\n quantize,\n reverse as reverseof,\n scaleLinear,\n scaleLog,\n scalePow,\n scaleQuantile,\n scaleSymlog,\n scaleThreshold,\n scaleIdentity,\n ticks\n} from \"d3\";\nimport {positive, negative, finite} from \"../defined.js\";\nimport {arrayify, constant, orderof, slice, maybeNiceInterval, maybeRangeInterval} from \"../options.js\";\nimport {ordinalRange, quantitativeScheme} from \"./schemes.js\";\nimport {registry, radius, opacity, color, length} from \"./index.js\";\n\nexport const flip = (i) => (t) => i(1 - t);\nconst unit = [0, 1];\n\nconst interpolators = new Map([\n // numbers\n [\"number\", interpolateNumber],\n\n // color spaces\n [\"rgb\", interpolateRgb],\n [\"hsl\", interpolateHsl],\n [\"hcl\", interpolateHcl],\n [\"lab\", interpolateLab]\n]);\n\nexport function maybeInterpolator(interpolate) {\n const i = `${interpolate}`.toLowerCase();\n if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`);\n return interpolators.get(i);\n}\n\nexport function createScaleQ(\n key,\n scale,\n channels,\n {\n type,\n nice,\n clamp,\n zero,\n domain = inferAutoDomain(key, channels),\n unknown,\n round,\n scheme,\n interval,\n range = registry.get(key) === radius\n ? inferRadialRange(channels, domain)\n : registry.get(key) === length\n ? inferLengthRange(channels, domain)\n : registry.get(key) === opacity\n ? unit\n : undefined,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : type === \"cyclical\" ? \"rainbow\" : \"turbo\")\n : round\n ? interpolateRound\n : interpolateNumber,\n reverse\n }\n) {\n interval = maybeRangeInterval(interval, type);\n if (type === \"cyclical\" || type === \"sequential\") type = \"linear\"; // shorthand for color schemes\n reverse = !!reverse;\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n if (interpolate.length === 1) {\n if (reverse) {\n interpolate = flip(interpolate);\n reverse = false;\n }\n if (range === undefined) {\n range = Float64Array.from(domain, (_, i) => i / (domain.length - 1));\n if (range.length === 2) range = unit; // optimize common case of [0, 1]\n }\n scale.interpolate((range === unit ? constant : interpolatePiecewise)(interpolate));\n } else {\n scale.interpolate(interpolate);\n }\n\n // If a zero option is specified, we assume that the domain is numeric, and we\n // want to ensure that the domain crosses zero. However, note that the domain\n // may be reversed (descending) so we shouldn’t assume that the first value is\n // smaller than the last; and also it’s possible that the domain has more than\n // two values for a “poly” scale. And lastly be careful not to mutate input!\n if (zero) {\n const [min, max] = extent(domain);\n if (min > 0 || max < 0) {\n domain = slice(domain);\n if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0;\n // [2, 1] or [-2, -1]\n else domain[0] = 0; // [1, 2] or [-1, -2]\n }\n }\n\n if (reverse) domain = reverseof(domain);\n scale.domain(domain).unknown(unknown);\n if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain());\n if (range !== undefined) scale.range(range);\n if (clamp) scale.clamp(clamp);\n return {type, domain, range, scale, interpolate, interval};\n}\n\nfunction maybeNice(nice, type) {\n return nice === true ? undefined : typeof nice === \"number\" ? nice : maybeNiceInterval(nice, type);\n}\n\nexport function createScaleLinear(key, channels, options) {\n return createScaleQ(key, scaleLinear(), channels, options);\n}\n\nexport function createScaleSqrt(key, channels, options) {\n return createScalePow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScalePow(key, channels, {exponent = 1, ...options}) {\n return createScaleQ(key, scalePow().exponent(exponent), channels, {...options, type: \"pow\"});\n}\n\nexport function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) {\n return createScaleQ(key, scaleLog().base(base), channels, {...options, domain});\n}\n\nexport function createScaleSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleQ(key, scaleSymlog().constant(constant), channels, options);\n}\n\nexport function createScaleQuantile(\n key,\n channels,\n {\n range,\n quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead\n n = quantiles,\n scheme = \"rdylbu\",\n domain = inferQuantileDomain(channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n if (range === undefined) {\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n }\n if (domain.length > 0) {\n domain = scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles();\n }\n return createScaleThreshold(key, channels, {domain, range, reverse, unknown});\n}\n\nexport function createScaleQuantize(\n key,\n channels,\n {\n range,\n n = range === undefined ? 5 : (range = [...range]).length,\n scheme = \"rdylbu\",\n domain = inferAutoDomain(key, channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n const [min, max] = extent(domain);\n let thresholds;\n if (range === undefined) {\n thresholds = ticks(min, max, n); // approximate number of nice, round thresholds\n if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound\n if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound\n n = thresholds.length + 1;\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n } else {\n thresholds = quantize(interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range\n if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types\n }\n if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain\n return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown});\n}\n\nexport function createScaleThreshold(\n key,\n channels,\n {\n domain = [0], // explicit thresholds in ascending order\n unknown,\n scheme = \"rdylbu\",\n interpolate,\n range = interpolate !== undefined\n ? quantize(interpolate, domain.length + 1)\n : registry.get(key) === color\n ? ordinalRange(scheme, domain.length + 1)\n : undefined,\n reverse\n }\n) {\n domain = arrayify(domain);\n const sign = orderof(domain); // preserve descending domain\n if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`);\n if (reverse) range = reverseof(range); // domain ascending, so reverse range\n return {\n type: \"threshold\",\n scale: scaleThreshold(sign < 0 ? reverseof(domain) : domain, range === undefined ? [] : range).unknown(unknown),\n domain,\n range\n };\n}\n\nfunction isOrdered(domain, sign) {\n for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) {\n const s = descending(d, (d = domain[i]));\n if (s !== 0 && s !== sign) return false;\n }\n return true;\n}\n\nexport function createScaleIdentity() {\n return {type: \"identity\", scale: scaleIdentity()};\n}\n\nexport function inferDomain(channels, f = finite) {\n return channels.length\n ? [\n min(channels, ({value}) => (value === undefined ? value : min(value, f))),\n max(channels, ({value}) => (value === undefined ? value : max(value, f)))\n ]\n : [0, 1];\n}\n\nfunction inferAutoDomain(key, channels) {\n const type = registry.get(key);\n return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain)(channels);\n}\n\nfunction inferZeroDomain(channels) {\n return [0, channels.length ? max(channels, ({value}) => (value === undefined ? value : max(value, finite))) : 1];\n}\n\n// We don’t want the upper bound of the radial domain to be zero, as this would\n// be degenerate, so we ignore nonpositive values. We also don’t want the\n// maximum default radius to exceed 30px.\nfunction inferRadialRange(channels, domain) {\n const hint = channels.find(({radius}) => radius !== undefined);\n if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins\n const h25 = quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : quantile(value, 0.25, positive)));\n const range = domain.map((d) => 3 * Math.sqrt(d / h25));\n const k = 30 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\n// We want a length scale’s domain to go from zero to a positive value, and to\n// treat negative lengths if any as inverted vectors of equivalent magnitude. We\n// also don’t want the maximum default length to exceed 60px.\nfunction inferLengthRange(channels, domain) {\n const h50 = median(channels, ({value}) => (value === undefined ? NaN : median(value, Math.abs)));\n const range = domain.map((d) => (12 * d) / h50);\n const k = 60 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\nfunction inferLogDomain(channels) {\n for (const {value} of channels) {\n if (value !== undefined) {\n for (let v of value) {\n if (v > 0) return inferDomain(channels, positive);\n if (v < 0) return inferDomain(channels, negative);\n }\n }\n }\n return [1, 10];\n}\n\nfunction inferQuantileDomain(channels) {\n const domain = [];\n for (const {value} of channels) {\n if (value === undefined) continue;\n for (const v of value) domain.push(v);\n }\n return domain;\n}\n\nexport function interpolatePiecewise(interpolate) {\n return (i, j) => (t) => interpolate(i + t * (j - i));\n}\n","import {\n descending,\n interpolateNumber,\n interpolateRgb,\n piecewise,\n scaleDiverging,\n scaleDivergingLog,\n scaleDivergingPow,\n scaleDivergingSymlog\n} from \"d3\";\nimport {positive, negative} from \"../defined.js\";\nimport {quantitativeScheme} from \"./schemes.js\";\nimport {registry, color} from \"./index.js\";\nimport {inferDomain, maybeInterpolator, flip, interpolatePiecewise} from \"./quantitative.js\";\n\nfunction createScaleD(\n key,\n scale,\n transform,\n channels,\n {\n type,\n nice,\n clamp,\n domain = inferDomain(channels),\n unknown,\n pivot = 0,\n scheme,\n range,\n symmetric = true,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : \"rdbu\")\n : interpolateNumber,\n reverse\n }\n) {\n pivot = +pivot;\n let [min, max] = domain;\n if (descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse);\n min = Math.min(min, pivot);\n max = Math.max(max, pivot);\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n\n // If an explicit range is specified, promote it to a piecewise interpolator.\n if (range !== undefined) {\n interpolate =\n interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : piecewise(interpolate, range);\n }\n\n // Reverse before normalization.\n if (reverse) interpolate = flip(interpolate);\n\n // Normalize the interpolator for symmetric difference around the pivot.\n if (symmetric) {\n const mid = transform.apply(pivot);\n const mindelta = mid - transform.apply(min);\n const maxdelta = transform.apply(max) - mid;\n if (mindelta < maxdelta) min = transform.invert(mid - maxdelta);\n else if (mindelta > maxdelta) max = transform.invert(mid + mindelta);\n }\n\n scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate);\n if (clamp) scale.clamp(clamp);\n if (nice) scale.nice(nice);\n return {type, domain: [min, max], pivot, interpolate, scale};\n}\n\nexport function createScaleDiverging(key, channels, options) {\n return createScaleD(key, scaleDiverging(), transformIdentity, channels, options);\n}\n\nexport function createScaleDivergingSqrt(key, channels, options) {\n return createScaleDivergingPow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) {\n return createScaleD(key, scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, {\n ...options,\n type: \"diverging-pow\"\n });\n}\n\nexport function createScaleDivergingLog(\n key,\n channels,\n {base = 10, pivot = 1, domain = inferDomain(channels, pivot < 0 ? negative : positive), ...options}\n) {\n return createScaleD(key, scaleDivergingLog().base((base = +base)), transformLog, channels, {\n domain,\n pivot,\n ...options\n });\n}\n\nexport function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleD(\n key,\n scaleDivergingSymlog().constant((constant = +constant)),\n transformSymlog(constant),\n channels,\n options\n );\n}\n\nconst transformIdentity = {\n apply(x) {\n return x;\n },\n invert(x) {\n return x;\n }\n};\n\nconst transformLog = {\n apply: Math.log,\n invert: Math.exp\n};\n\nconst transformSqrt = {\n apply(x) {\n return Math.sign(x) * Math.sqrt(Math.abs(x));\n },\n invert(x) {\n return Math.sign(x) * (x * x);\n }\n};\n\nfunction transformPow(exponent) {\n return exponent === 0.5\n ? transformSqrt\n : {\n apply(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), exponent);\n },\n invert(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent);\n }\n };\n}\n\nfunction transformSymlog(constant) {\n return {\n apply(x) {\n return Math.sign(x) * Math.log1p(Math.abs(x / constant));\n },\n invert(x) {\n return Math.sign(x) * Math.expm1(Math.abs(x)) * constant;\n }\n };\n}\n","import {scaleTime, scaleUtc} from \"d3\";\nimport {createScaleQ} from \"./quantitative.js\";\n\nfunction createScaleT(key, scale, channels, options) {\n return createScaleQ(key, scale, channels, options);\n}\n\nexport function createScaleTime(key, channels, options) {\n return createScaleT(key, scaleTime(), channels, options);\n}\n\nexport function createScaleUtc(key, channels, options) {\n return createScaleT(key, scaleUtc(), channels, options);\n}\n","import {InternSet, extent, quantize, reverse as reverseof, sort, symbolsFill, symbolsStroke} from \"d3\";\nimport {scaleBand, scaleOrdinal, scalePoint, scaleImplicit} from \"d3\";\nimport {ascendingDefined} from \"../defined.js\";\nimport {isNoneish, map, maybeRangeInterval} from \"../options.js\";\nimport {maybeSymbol} from \"../symbol.js\";\nimport {registry, color, position, symbol} from \"./index.js\";\nimport {maybeBooleanRange, ordinalScheme, quantitativeScheme} from \"./schemes.js\";\n\n// This denotes an implicitly ordinal color scale: the scale type was not set,\n// but the associated values are strings or booleans. If the associated defined\n// values are entirely boolean, the range will default to greys. You can opt out\n// of this by setting the type explicitly.\nexport const ordinalImplicit = Symbol(\"ordinal\");\n\nfunction createScaleO(key, scale, channels, {type, interval, domain, range, reverse, hint}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n if (type === \"categorical\" || type === ordinalImplicit) type = \"ordinal\"; // shorthand for color schemes\n if (reverse) domain = reverseof(domain);\n scale.domain(domain);\n if (range !== undefined) {\n // If the range is specified as a function, pass it the domain.\n if (typeof range === \"function\") range = range(domain);\n scale.range(range);\n }\n return {type, domain, range, scale, hint, interval};\n}\n\nexport function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n let hint;\n if (registry.get(key) === symbol) {\n hint = inferSymbolHint(channels);\n range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol);\n } else if (registry.get(key) === color) {\n if (range === undefined && (type === \"ordinal\" || type === ordinalImplicit)) {\n range = maybeBooleanRange(domain, scheme);\n if (range !== undefined) scheme = undefined; // Don’t re-apply scheme.\n }\n if (scheme === undefined && range === undefined) {\n scheme = type === \"ordinal\" ? \"turbo\" : \"tableau10\";\n }\n if (scheme !== undefined) {\n if (range !== undefined) {\n const interpolate = quantitativeScheme(scheme);\n const t0 = range[0],\n d = range[1] - range[0];\n range = ({length: n}) => quantize((t) => interpolate(t0 + d * t), n);\n } else {\n range = ordinalScheme(scheme);\n }\n }\n }\n if (unknown === scaleImplicit) {\n throw new Error(`implicit unknown on ${key} scale is not supported`);\n }\n return createScaleO(key, scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint});\n}\n\nexport function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) {\n return maybeRound(scalePoint().align(align).padding(padding), channels, options, key);\n}\n\nexport function createScaleBand(\n key,\n channels,\n {\n align = 0.5,\n padding = 0.1,\n paddingInner = padding,\n paddingOuter = key === \"fx\" || key === \"fy\" ? 0 : padding,\n ...options\n }\n) {\n return maybeRound(\n scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter),\n channels,\n options,\n key\n );\n}\n\nfunction maybeRound(scale, channels, options, key) {\n let {round} = options;\n if (round !== undefined) scale.round((round = !!round));\n scale = createScaleO(key, scale, channels, options);\n scale.round = round; // preserve for autoScaleRound\n return scale;\n}\n\nfunction inferDomain(channels, interval, key) {\n const values = new InternSet();\n for (const {value, domain} of channels) {\n if (domain !== undefined) return domain(); // see channelDomain\n if (value === undefined) continue;\n for (const v of value) values.add(v);\n }\n if (interval !== undefined) {\n const [min, max] = extent(values).map(interval.floor, interval);\n return interval.range(min, interval.offset(max));\n }\n if (values.size > 10e3 && registry.get(key) === position) {\n throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`);\n }\n return sort(values, ascendingDefined);\n}\n\n// If all channels provide a consistent hint, propagate it to the scale.\nfunction inferHint(channels, key) {\n let value;\n for (const {hint} of channels) {\n const candidate = hint?.[key];\n if (candidate === undefined) continue; // no hint here\n if (value === undefined) value = candidate;\n // first hint\n else if (value !== candidate) return; // inconsistent hint\n }\n return value;\n}\n\nfunction inferSymbolHint(channels) {\n return {\n fill: inferHint(channels, \"fill\"),\n stroke: inferHint(channels, \"stroke\")\n };\n}\n\nfunction inferSymbolRange(hint) {\n return isNoneish(hint.fill) ? symbolsStroke : symbolsFill;\n}\n","import {\n isOrdinal,\n isTemporal,\n isTemporalString,\n isNumericString,\n isScaleOptions,\n map,\n slice,\n coerceNumbers,\n coerceDates\n} from \"./options.js\";\nimport {registry, color, position, radius, opacity, symbol, length} from \"./scales/index.js\";\nimport {\n createScaleLinear,\n createScaleSqrt,\n createScalePow,\n createScaleLog,\n createScaleSymlog,\n createScaleQuantile,\n createScaleQuantize,\n createScaleThreshold,\n createScaleIdentity\n} from \"./scales/quantitative.js\";\nimport {\n createScaleDiverging,\n createScaleDivergingSqrt,\n createScaleDivergingPow,\n createScaleDivergingLog,\n createScaleDivergingSymlog\n} from \"./scales/diverging.js\";\nimport {isDivergingScheme} from \"./scales/schemes.js\";\nimport {createScaleTime, createScaleUtc} from \"./scales/temporal.js\";\nimport {createScaleOrdinal, createScalePoint, createScaleBand, ordinalImplicit} from \"./scales/ordinal.js\";\nimport {maybeSymbol} from \"./symbol.js\";\nimport {warn} from \"./warnings.js\";\n\nexport function createScales(\n channelsByScale,\n {\n label: globalLabel,\n inset: globalInset = 0,\n insetTop: globalInsetTop = globalInset,\n insetRight: globalInsetRight = globalInset,\n insetBottom: globalInsetBottom = globalInset,\n insetLeft: globalInsetLeft = globalInset,\n round,\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n facet: {label: facetLabel = globalLabel} = {},\n ...options\n } = {}\n) {\n const scales = {};\n for (const [key, channels] of channelsByScale) {\n const scaleOptions = options[key];\n const scale = createScale(key, channels, {\n round: registry.get(key) === position ? round : undefined, // only for position\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n ...scaleOptions\n });\n if (scale) {\n // populate generic scale options (percent, transform, insets)\n let {\n label = key === \"fx\" || key === \"fy\" ? facetLabel : globalLabel,\n percent,\n transform,\n inset,\n insetTop = inset !== undefined ? inset : key === \"y\" ? globalInsetTop : 0, // not fy\n insetRight = inset !== undefined ? inset : key === \"x\" ? globalInsetRight : 0, // not fx\n insetBottom = inset !== undefined ? inset : key === \"y\" ? globalInsetBottom : 0, // not fy\n insetLeft = inset !== undefined ? inset : key === \"x\" ? globalInsetLeft : 0 // not fx\n } = scaleOptions || {};\n if (transform == null) transform = undefined;\n else if (typeof transform !== \"function\") throw new Error(\"invalid scale transform; not a function\");\n scale.percent = !!percent;\n scale.label = label === undefined ? inferScaleLabel(channels, scale) : label;\n scale.transform = transform;\n if (key === \"x\" || key === \"fx\") {\n scale.insetLeft = +insetLeft;\n scale.insetRight = +insetRight;\n } else if (key === \"y\" || key === \"fy\") {\n scale.insetTop = +insetTop;\n scale.insetBottom = +insetBottom;\n }\n scales[key] = scale;\n }\n }\n return scales;\n}\n\nexport function createScaleFunctions(scales) {\n return Object.fromEntries(\n Object.entries(scales)\n .filter(([, {scale}]) => scale) // drop identity scales\n .map(([name, {scale, type, interval, label}]) => {\n scale.type = type; // for axis\n if (interval != null) scale.interval = interval; // for axis\n if (label != null) scale.label = label; // for axis\n return [name, scale];\n })\n );\n}\n\n// Mutates scale.range!\nexport function autoScaleRange(scales, dimensions) {\n const {x, y, fx, fy} = scales;\n const superdimensions = fx || fy ? outerDimensions(dimensions) : dimensions;\n if (fx) autoScaleRangeX(fx, superdimensions);\n if (fy) autoScaleRangeY(fy, superdimensions);\n const subdimensions = fx || fy ? innerDimensions(scales, dimensions) : dimensions;\n if (x) autoScaleRangeX(x, subdimensions);\n if (y) autoScaleRangeY(y, subdimensions);\n}\n\n// Channels can have labels; if all the channels for a given scale are\n// consistently labeled (i.e., have the same value if not undefined), and the\n// corresponding scale doesn’t already have an explicit label, then the\n// channels’ label is promoted to the scale. This inferred label should have an\n// orientation-appropriate arrow added when used as an axis, but we don’t want\n// to add the arrow when the label is set explicitly as an option; so, the\n// inferred label is distinguished as an object with an “inferred” property.\nfunction inferScaleLabel(channels = [], scale) {\n let label;\n for (const {label: l} of channels) {\n if (l === undefined) continue;\n if (label === undefined) label = l;\n else if (label !== l) return;\n }\n if (label === undefined) return;\n // Ignore the implicit label for temporal scales if it’s simply “date”.\n if (isTemporalScale(scale) && /^(date|time|year)$/i.test(label)) return;\n if (!isOrdinalScale(scale) && scale.percent) label = `${label} (%)`;\n return {inferred: true, toString: () => label};\n}\n\n// Returns the dimensions of the outer frame; this is subdivided into facets\n// with the margins of each facet collapsing into the outer margins.\nexport function outerDimensions(dimensions) {\n const {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width,\n height,\n facet: {\n marginTop: facetMarginTop,\n marginRight: facetMarginRight,\n marginBottom: facetMarginBottom,\n marginLeft: facetMarginLeft\n }\n } = dimensions;\n return {\n marginTop: Math.max(marginTop, facetMarginTop),\n marginRight: Math.max(marginRight, facetMarginRight),\n marginBottom: Math.max(marginBottom, facetMarginBottom),\n marginLeft: Math.max(marginLeft, facetMarginLeft),\n width,\n height\n };\n}\n\n// Returns the dimensions of each facet.\nexport function innerDimensions({fx, fy}, dimensions) {\n const {marginTop, marginRight, marginBottom, marginLeft, width, height} = outerDimensions(dimensions);\n return {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width: fx ? fx.scale.bandwidth() + marginLeft + marginRight : width,\n height: fy ? fy.scale.bandwidth() + marginTop + marginBottom : height\n };\n}\n\nfunction autoScaleRangeX(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetLeft, insetRight} = scale;\n const {width, marginLeft = 0, marginRight = 0} = dimensions;\n const left = marginLeft + insetLeft;\n const right = width - marginRight - insetRight;\n scale.range = [left, Math.max(left, right)];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRangeY(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetTop, insetBottom} = scale;\n const {height, marginTop = 0, marginBottom = 0} = dimensions;\n const top = marginTop + insetTop;\n const bottom = height - marginBottom - insetBottom;\n scale.range = [Math.max(top, bottom), top];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n else scale.range.reverse();\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRound(scale) {\n if (scale.round === undefined && isBandScale(scale) && roundError(scale) <= 30) {\n scale.scale.round(true);\n }\n}\n\n// If we were to turn on rounding for this band or point scale, how much wasted\n// space would it introduce (on both ends of the range)? This must match\n// d3.scaleBand’s rounding behavior:\n// https://github.com/d3/d3-scale/blob/83555bd759c7314420bd4240642beda5e258db9e/src/band.js#L20-L32\nfunction roundError({scale}) {\n const n = scale.domain().length;\n const [start, stop] = scale.range();\n const paddingInner = scale.paddingInner ? scale.paddingInner() : 1;\n const paddingOuter = scale.paddingOuter ? scale.paddingOuter() : scale.padding();\n const m = n - paddingInner;\n const step = Math.abs(stop - start) / Math.max(1, m + paddingOuter * 2);\n return (step - Math.floor(step)) * m;\n}\n\nfunction piecewiseRange(scale) {\n const length = scale.scale.domain().length + isThresholdScale(scale);\n if (!(length > 2)) return scale.range;\n const [start, end] = scale.range;\n return Array.from({length}, (_, i) => start + (i / (length - 1)) * (end - start));\n}\n\nexport function normalizeScale(key, scale, hint) {\n return createScale(key, hint === undefined ? undefined : [{hint}], {...scale});\n}\n\nfunction createScale(key, channels = [], options = {}) {\n const type = inferScaleType(key, channels, options);\n\n // Warn for common misuses of implicit ordinal scales. We disable this test if\n // you specify a scale interval or if you set the domain or range explicitly,\n // since setting the domain or range (typically with a cardinality of more than\n // two) is another indication that you intended for the scale to be ordinal; we\n // also disable it for facet scales since these are always band scales.\n if (\n options.type === undefined &&\n options.domain === undefined &&\n options.range === undefined &&\n options.interval == null &&\n key !== \"fx\" &&\n key !== \"fy\" &&\n isOrdinalScale({type})\n ) {\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isTemporal))\n warn(\n `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isTemporalString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isNumericString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a \"linear\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n }\n\n options.type = type; // Mutates input!\n\n // Once the scale type is known, coerce the associated channel values and any\n // explicitly-specified domain to the expected type.\n switch (type) {\n case \"diverging\":\n case \"diverging-sqrt\":\n case \"diverging-pow\":\n case \"diverging-log\":\n case \"diverging-symlog\":\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n case \"sqrt\":\n case \"threshold\":\n case \"quantile\":\n case \"pow\":\n case \"log\":\n case \"symlog\":\n options = coerceType(channels, options, coerceNumbers);\n break;\n case \"identity\":\n switch (registry.get(key)) {\n case position:\n options = coerceType(channels, options, coerceNumbers);\n break;\n case symbol:\n options = coerceType(channels, options, coerceSymbols);\n break;\n }\n break;\n case \"utc\":\n case \"time\":\n options = coerceType(channels, options, coerceDates);\n break;\n }\n\n switch (type) {\n case \"diverging\":\n return createScaleDiverging(key, channels, options);\n case \"diverging-sqrt\":\n return createScaleDivergingSqrt(key, channels, options);\n case \"diverging-pow\":\n return createScaleDivergingPow(key, channels, options);\n case \"diverging-log\":\n return createScaleDivergingLog(key, channels, options);\n case \"diverging-symlog\":\n return createScaleDivergingSymlog(key, channels, options);\n case \"categorical\":\n case \"ordinal\":\n case ordinalImplicit:\n return createScaleOrdinal(key, channels, options);\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n return createScaleLinear(key, channels, options);\n case \"sqrt\":\n return createScaleSqrt(key, channels, options);\n case \"threshold\":\n return createScaleThreshold(key, channels, options);\n case \"quantile\":\n return createScaleQuantile(key, channels, options);\n case \"quantize\":\n return createScaleQuantize(key, channels, options);\n case \"pow\":\n return createScalePow(key, channels, options);\n case \"log\":\n return createScaleLog(key, channels, options);\n case \"symlog\":\n return createScaleSymlog(key, channels, options);\n case \"utc\":\n return createScaleUtc(key, channels, options);\n case \"time\":\n return createScaleTime(key, channels, options);\n case \"point\":\n return createScalePoint(key, channels, options);\n case \"band\":\n return createScaleBand(key, channels, options);\n case \"identity\":\n return registry.get(key) === position ? createScaleIdentity() : {type: \"identity\"};\n case undefined:\n return;\n default:\n throw new Error(`unknown scale type: ${type}`);\n }\n}\n\nfunction formatScaleType(type) {\n return typeof type === \"symbol\" ? type.description : type;\n}\n\n// A special type symbol when the x and y scales are replaced with a projection.\nconst typeProjection = {toString: () => \"projection\"};\n\nfunction inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) {\n // The facet scales are always band scales; this cannot be changed.\n if (key === \"fx\" || key === \"fy\") return \"band\";\n\n // If a projection is specified, the x- and y-scales are disabled; these\n // channels will be projected rather than scaled. (But still check that none\n // of the associated channels are incompatible with a projection.)\n if ((key === \"x\" || key === \"y\") && projection != null) type = typeProjection;\n\n // If a channel dictates a scale type, make sure that it is consistent with\n // the user-specified scale type (if any) and all other channels. For example,\n // barY requires x to be a band scale and disallows any other scale type.\n for (const {type: t} of channels) {\n if (t === undefined) continue;\n else if (type === undefined) type = t;\n else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`);\n }\n\n // If the scale, a channel, or user specified a (consistent) type, return it.\n if (type === typeProjection) return;\n if (type !== undefined) return type;\n\n // If there’s no data (and no type) associated with this scale, don’t create a scale.\n if (domain === undefined && !channels.some(({value}) => value !== undefined)) return;\n\n // Some scales have default types.\n const kind = registry.get(key);\n if (kind === radius) return \"sqrt\";\n if (kind === opacity || kind === length) return \"linear\";\n if (kind === symbol) return \"ordinal\";\n\n // If the domain or range has more than two values, assume it’s ordinal. You\n // can still use a “piecewise” (or “polylinear”) scale, but you must set the\n // type explicitly.\n if ((domain || range || []).length > 2) return asOrdinalType(kind);\n\n // Otherwise, infer the scale type from the data! Prefer the domain, if\n // present, over channels. (The domain and channels should be consistently\n // typed, and the domain is more explicit and typically much smaller.) We only\n // check the first defined value for expedience and simplicity; we expect\n // that the types are consistent.\n if (domain !== undefined) {\n if (isOrdinal(domain)) return asOrdinalType(kind);\n if (isTemporal(domain)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n }\n\n // If any channel is ordinal or temporal, it takes priority.\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isOrdinal)) return asOrdinalType(kind);\n if (values.some(isTemporal)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n}\n\n// Positional scales default to a point scale instead of an ordinal scale.\nfunction asOrdinalType(kind) {\n switch (kind) {\n case position:\n return \"point\";\n case color:\n return ordinalImplicit;\n default:\n return \"ordinal\";\n }\n}\n\nexport function isTemporalScale({type}) {\n return type === \"time\" || type === \"utc\";\n}\n\nexport function isOrdinalScale({type}) {\n return type === \"ordinal\" || type === \"point\" || type === \"band\" || type === ordinalImplicit;\n}\n\nexport function isThresholdScale({type}) {\n return type === \"threshold\";\n}\n\nfunction isBandScale({type}) {\n return type === \"point\" || type === \"band\";\n}\n\nexport function isDivergingScale({type}) {\n return /^diverging($|-)/.test(type);\n}\n\n// Certain marks have special behavior if a scale is collapsed, i.e. if the\n// domain is degenerate and represents only a single value such as [3, 3]; for\n// example, a rect will span the full extent of the chart along a collapsed\n// dimension (whereas a dot will simply be drawn in the center).\nexport function isCollapsed(scale) {\n if (scale === undefined) return true; // treat missing scale as collapsed\n const domain = scale.domain();\n const value = scale(domain[0]);\n for (let i = 1, n = domain.length; i < n; ++i) {\n if (scale(domain[i]) - value) {\n return false;\n }\n }\n return true;\n}\n\n// Mutates channel.value!\nfunction coerceType(channels, {domain, ...options}, coerceValues) {\n for (const c of channels) {\n if (c.value !== undefined) {\n c.value = coerceValues(c.value);\n }\n }\n return {\n domain: domain === undefined ? domain : coerceValues(domain),\n ...options\n };\n}\n\nfunction coerceSymbols(values) {\n return map(values, maybeSymbol);\n}\n\nexport function scale(options = {}) {\n let scale;\n for (const key in options) {\n if (!registry.has(key)) continue; // ignore unknown properties\n if (!isScaleOptions(options[key])) continue; // e.g., ignore {color: \"red\"}\n if (scale !== undefined) throw new Error(\"ambiguous scale definition; multiple scales found\");\n scale = exposeScale(normalizeScale(key, options[key]));\n }\n if (scale === undefined) throw new Error(\"invalid scale definition; no scale found\");\n return scale;\n}\n\nexport function exposeScales(scaleDescriptors) {\n return (key) => {\n if (!registry.has((key = `${key}`))) throw new Error(`unknown scale: ${key}`);\n return key in scaleDescriptors ? exposeScale(scaleDescriptors[key]) : undefined;\n };\n}\n\n// Note: axis- and legend-related properties (such as label, ticks and\n// tickFormat) are not included here as they do not affect the scale’s behavior.\nfunction exposeScale({scale, type, domain, range, interpolate, interval, transform, percent, pivot}) {\n if (type === \"identity\") return {type: \"identity\", apply: (d) => d, invert: (d) => d};\n const unknown = scale.unknown ? scale.unknown() : undefined;\n return {\n type,\n domain: slice(domain), // defensive copy\n ...(range !== undefined && {range: slice(range)}), // defensive copy\n ...(transform !== undefined && {transform}),\n ...(percent && {percent}), // only exposed if truthy\n ...(unknown !== undefined && {unknown}),\n ...(interval !== undefined && {interval}),\n\n // quantitative\n ...(interpolate !== undefined && {interpolate}),\n ...(scale.clamp && {clamp: scale.clamp()}),\n\n // diverging (always asymmetric; we never want to apply the symmetric transform twice)\n ...(pivot !== undefined && {pivot, symmetric: false}),\n\n // log, diverging-log\n ...(scale.base && {base: scale.base()}),\n\n // pow, diverging-pow\n ...(scale.exponent && {exponent: scale.exponent()}),\n\n // symlog, diverging-symlog\n ...(scale.constant && {constant: scale.constant()}),\n\n // band, point\n ...(scale.align && {align: scale.align(), round: scale.round()}),\n ...(scale.padding &&\n (scale.paddingInner\n ? {paddingInner: scale.paddingInner(), paddingOuter: scale.paddingOuter()}\n : {padding: scale.padding()})),\n ...(scale.bandwidth && {bandwidth: scale.bandwidth(), step: scale.step()}),\n\n // utilities\n apply: (t) => scale(t),\n ...(scale.invert && {invert: (t) => scale.invert(t)})\n };\n}\n","// @ts-ignore\nimport { scale } from '@observablehq/plot';\nimport { OptionsType } from './options/Options';\nimport { SCALE_BASE_OPACITY_COLOR } from './constant';\n\nimport type { SubDomain } from './index';\n\ntype ValueType = string | number | undefined;\n\nexport function normalizedScale(scaleOptions: OptionsType['scale']): any {\n try {\n const scaleType = Object.keys(scaleOptions!)[0];\n\n return scale({\n [scaleType]: {\n ...scaleOptions![scaleType as 'color' | 'opacity'],\n clamp: true,\n },\n });\n } catch (error) {\n return null;\n }\n}\n\nfunction scaleStyle(_scale: any, scaleOptions: OptionsType['scale']) {\n const styles: { fill?: Function; 'fill-opacity'?: Function } = {};\n\n if (scaleOptions!.hasOwnProperty('opacity')) {\n styles.fill = () =>\n // eslint-disable-next-line implicit-arrow-linebreak\n scaleOptions!.opacity!.baseColor || SCALE_BASE_OPACITY_COLOR;\n styles['fill-opacity'] = (d: ValueType) => _scale?.apply(d);\n } else {\n styles.fill = (d: ValueType) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n (typeof d === 'string' && d?.startsWith('#') ? d : _scale?.apply(d));\n }\n\n return styles;\n}\n\nexport function applyScaleStyle(\n elem: any,\n _scale: any,\n scaleOptions: OptionsType['scale'],\n keyname?: string,\n) {\n Object.entries(scaleStyle(_scale, scaleOptions)).forEach(([prop, val]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n elem.style(prop, (d: SubDomain | string) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n val(keyname ? (d as SubDomain)[keyname as keyof SubDomain] : d)));\n}\n","import isFunction from 'lodash-es/isFunction';\nimport { hcl } from 'd3-color';\nimport { normalizedScale, applyScaleStyle } from '../scale';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { SubDomain, Timestamp } from '../index';\n\nexport default class Populator {\n calendar: CalHeatmap;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n }\n\n populate(): void {\n const { calendar } = this;\n const { scale, subDomain } = calendar.options.options;\n const colorScale = normalizedScale(scale);\n\n calendar.calendarPainter\n .root!.selectAll('.ch-domain')\n .selectAll('svg')\n .selectAll('g')\n .data((d: Timestamp) => calendar.domainCollection.get(d) || [])\n .call((element: any) => {\n applyScaleStyle(element.select('rect'), colorScale, scale!, 'v');\n })\n .call((element: any) => {\n element\n .select('text')\n .attr('style', (d: SubDomain) => {\n const defaultColor =\n hcl(colorScale?.apply(d.v)).l > 60 ? '#000' : '#fff';\n let color = subDomain.color || (d.v ? defaultColor : null);\n\n if (isFunction(color)) {\n color = color(d.t, d.v, colorScale?.apply(d.v));\n }\n\n if (!color) {\n return null;\n }\n\n return `fill: ${color};`;\n })\n .text((d: SubDomain, i: number, nodes: any[]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n calendar.dateHelper.format(d.t, subDomain.label, d.v, nodes[i]));\n })\n .call(() => {\n calendar.eventEmitter.emit('fill');\n });\n }\n}\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\nexport default eq;\n","import eq from './eq.js';\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\nexport default assocIndexOf;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n --this.size;\n return true;\n}\n\nexport default listCacheDelete;\n","import listCacheClear from './_listCacheClear.js';\nimport listCacheDelete from './_listCacheDelete.js';\nimport listCacheGet from './_listCacheGet.js';\nimport listCacheHas from './_listCacheHas.js';\nimport listCacheSet from './_listCacheSet.js';\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nexport default ListCache;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n this.__data__ = [];\n this.size = 0;\n}\n\nexport default listCacheClear;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\nexport default listCacheGet;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\nexport default listCacheHas;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n ++this.size;\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\nexport default listCacheSet;\n","import root from './_root.js';\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nexport default coreJsData;\n","import coreJsData from './_coreJsData.js';\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\nexport default isMasked;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\nexport default toSource;\n","import isFunction from './isFunction.js';\nimport isMasked from './_isMasked.js';\nimport isObject from './isObject.js';\nimport toSource from './_toSource.js';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\nfunction baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\nexport default baseIsNative;\n","import baseIsNative from './_baseIsNative.js';\nimport getValue from './_getValue.js';\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\nexport default getNative;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\nexport default getValue;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nexport default Map;\n","import getNative from './_getNative.js';\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nexport default nativeCreate;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nexport default hashGet;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nexport default hashHas;\n","import hashClear from './_hashClear.js';\nimport hashDelete from './_hashDelete.js';\nimport hashGet from './_hashGet.js';\nimport hashHas from './_hashHas.js';\nimport hashSet from './_hashSet.js';\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nexport default Hash;\n","import isKeyable from './_isKeyable.js';\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\nexport default getMapData;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\nexport default isKeyable;\n","import mapCacheClear from './_mapCacheClear.js';\nimport mapCacheDelete from './_mapCacheDelete.js';\nimport mapCacheGet from './_mapCacheGet.js';\nimport mapCacheHas from './_mapCacheHas.js';\nimport mapCacheSet from './_mapCacheSet.js';\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nexport default MapCache;\n","import nativeCreate from './_nativeCreate.js';\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n this.size = 0;\n}\n\nexport default hashClear;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n var result = this.has(key) && delete this.__data__[key];\n this.size -= result ? 1 : 0;\n return result;\n}\n\nexport default hashDelete;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n var data = this.__data__;\n this.size += this.has(key) ? 0 : 1;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\nexport default hashSet;\n","import Hash from './_Hash.js';\nimport ListCache from './_ListCache.js';\nimport Map from './_Map.js';\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n this.size = 0;\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n}\n\nexport default mapCacheClear;\n","import getMapData from './_getMapData.js';\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n var result = getMapData(this, key)['delete'](key);\n this.size -= result ? 1 : 0;\n return result;\n}\n\nexport default mapCacheDelete;\n","import getMapData from './_getMapData.js';\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\nexport default mapCacheGet;\n","import getMapData from './_getMapData.js';\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\nexport default mapCacheHas;\n","import getMapData from './_getMapData.js';\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n var data = getMapData(this, key),\n size = data.size;\n\n data.set(key, value);\n this.size += data.size == size ? 0 : 1;\n return this;\n}\n\nexport default mapCacheSet;\n","import ListCache from './_ListCache.js';\nimport stackClear from './_stackClear.js';\nimport stackDelete from './_stackDelete.js';\nimport stackGet from './_stackGet.js';\nimport stackHas from './_stackHas.js';\nimport stackSet from './_stackSet.js';\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n var data = this.__data__ = new ListCache(entries);\n this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nexport default Stack;\n","import ListCache from './_ListCache.js';\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n this.__data__ = new ListCache;\n this.size = 0;\n}\n\nexport default stackClear;\n","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n var data = this.__data__,\n result = data['delete'](key);\n\n this.size = data.size;\n return result;\n}\n\nexport default stackDelete;\n","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\nexport default stackGet;\n","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\nexport default stackHas;\n","import ListCache from './_ListCache.js';\nimport Map from './_Map.js';\nimport MapCache from './_MapCache.js';\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n var data = this.__data__;\n if (data instanceof ListCache) {\n var pairs = data.__data__;\n if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n this.size = ++data.size;\n return this;\n }\n data = this.__data__ = new MapCache(pairs);\n }\n data.set(key, value);\n this.size = data.size;\n return this;\n}\n\nexport default stackSet;\n","import getNative from './_getNative.js';\n\nvar defineProperty = (function() {\n try {\n var func = getNative(Object, 'defineProperty');\n func({}, '', {});\n return func;\n } catch (e) {}\n}());\n\nexport default defineProperty;\n","import defineProperty from './_defineProperty.js';\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n if (key == '__proto__' && defineProperty) {\n defineProperty(object, key, {\n 'configurable': true,\n 'enumerable': true,\n 'value': value,\n 'writable': true\n });\n } else {\n object[key] = value;\n }\n}\n\nexport default baseAssignValue;\n","import baseAssignValue from './_baseAssignValue.js';\nimport eq from './eq.js';\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n if ((value !== undefined && !eq(object[key], value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n}\n\nexport default assignMergeValue;\n","import createBaseFor from './_createBaseFor.js';\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\nexport default baseFor;\n","/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n return function(object, iteratee, keysFunc) {\n var index = -1,\n iterable = Object(object),\n props = keysFunc(object),\n length = props.length;\n\n while (length--) {\n var key = props[fromRight ? length : ++index];\n if (iteratee(iterable[key], key, iterable) === false) {\n break;\n }\n }\n return object;\n };\n}\n\nexport default createBaseFor;\n","import root from './_root.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var length = buffer.length,\n result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n buffer.copy(result);\n return result;\n}\n\nexport default cloneBuffer;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nexport default Uint8Array;\n","import cloneArrayBuffer from './_cloneArrayBuffer.js';\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nexport default cloneTypedArray;\n","import Uint8Array from './_Uint8Array.js';\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n}\n\nexport default cloneArrayBuffer;\n","import isObject from './isObject.js';\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n function object() {}\n return function(proto) {\n if (!isObject(proto)) {\n return {};\n }\n if (objectCreate) {\n return objectCreate(proto);\n }\n object.prototype = proto;\n var result = new object;\n object.prototype = undefined;\n return result;\n };\n}());\n\nexport default baseCreate;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\nexport default overArg;\n","import overArg from './_overArg.js';\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nexport default getPrototype;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n}\n\nexport default isPrototype;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nexport default baseIsArguments;\n","import baseIsArguments from './_baseIsArguments.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n !propertyIsEnumerable.call(value, 'callee');\n};\n\nexport default isArguments;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nexport default isLength;\n","import isFunction from './isFunction.js';\nimport isLength from './isLength.js';\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\nexport default isArrayLike;\n","import root from './_root.js';\nimport stubFalse from './stubFalse.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nexport default isBuffer;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n return false;\n}\n\nexport default stubFalse;\n","import baseGetTag from './_baseGetTag.js';\nimport getPrototype from './_getPrototype.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n return false;\n }\n var proto = getPrototype(value);\n if (proto === null) {\n return true;\n }\n var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n funcToString.call(Ctor) == objectCtorString;\n}\n\nexport default isPlainObject;\n","import baseGetTag from './_baseGetTag.js';\nimport isLength from './isLength.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nexport default baseIsTypedArray;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n try {\n // Use `util.types` for Node.js 10+.\n var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n if (types) {\n return types;\n }\n\n // Legacy `process.binding('util')` for Node.js < 10.\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n}());\n\nexport default nodeUtil;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n return function(value) {\n return func(value);\n };\n}\n\nexport default baseUnary;\n","import baseIsTypedArray from './_baseIsTypedArray.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nexport default isTypedArray;\n","/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n if (key === 'constructor' && typeof object[key] === 'function') {\n return;\n }\n\n if (key == '__proto__') {\n return;\n }\n\n return object[key];\n}\n\nexport default safeGet;\n","import baseAssignValue from './_baseAssignValue.js';\nimport eq from './eq.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n}\n\nexport default assignValue;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n var type = typeof value;\n length = length == null ? MAX_SAFE_INTEGER : length;\n\n return !!length &&\n (type == 'number' ||\n (type != 'symbol' && reIsUint.test(value))) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\nexport default isIndex;\n","import baseTimes from './_baseTimes.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isIndex from './_isIndex.js';\nimport isTypedArray from './isTypedArray.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n var isArr = isArray(value),\n isArg = !isArr && isArguments(value),\n isBuff = !isArr && !isArg && isBuffer(value),\n isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n skipIndexes = isArr || isArg || isBuff || isType,\n result = skipIndexes ? baseTimes(value.length, String) : [],\n length = result.length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (\n // Safari 9 has enumerable `arguments.length` in strict mode.\n key == 'length' ||\n // Node.js 0.10 has enumerable non-index properties on buffers.\n (isBuff && (key == 'offset' || key == 'parent')) ||\n // PhantomJS 2 has enumerable non-index properties on typed arrays.\n (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n // Skip index properties.\n isIndex(key, length)\n ))) {\n result.push(key);\n }\n }\n return result;\n}\n\nexport default arrayLikeKeys;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\nexport default baseTimes;\n","import isObject from './isObject.js';\nimport isPrototype from './_isPrototype.js';\nimport nativeKeysIn from './_nativeKeysIn.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n if (!isObject(object)) {\n return nativeKeysIn(object);\n }\n var isProto = isPrototype(object),\n result = [];\n\n for (var key in object) {\n if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n result.push(key);\n }\n }\n return result;\n}\n\nexport default baseKeysIn;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n var result = [];\n if (object != null) {\n for (var key in Object(object)) {\n result.push(key);\n }\n }\n return result;\n}\n\nexport default nativeKeysIn;\n","import arrayLikeKeys from './_arrayLikeKeys.js';\nimport baseKeysIn from './_baseKeysIn.js';\nimport isArrayLike from './isArrayLike.js';\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nexport default keysIn;\n","import copyObject from './_copyObject.js';\nimport keysIn from './keysIn.js';\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n return copyObject(value, keysIn(value));\n}\n\nexport default toPlainObject;\n","import assignValue from './_assignValue.js';\nimport baseAssignValue from './_baseAssignValue.js';\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n var isNew = !object;\n object || (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n if (newValue === undefined) {\n newValue = source[key];\n }\n if (isNew) {\n baseAssignValue(object, key, newValue);\n } else {\n assignValue(object, key, newValue);\n }\n }\n return object;\n}\n\nexport default copyObject;\n","import assignMergeValue from './_assignMergeValue.js';\nimport cloneBuffer from './_cloneBuffer.js';\nimport cloneTypedArray from './_cloneTypedArray.js';\nimport copyArray from './_copyArray.js';\nimport initCloneObject from './_initCloneObject.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isArrayLikeObject from './isArrayLikeObject.js';\nimport isBuffer from './isBuffer.js';\nimport isFunction from './isFunction.js';\nimport isObject from './isObject.js';\nimport isPlainObject from './isPlainObject.js';\nimport isTypedArray from './isTypedArray.js';\nimport safeGet from './_safeGet.js';\nimport toPlainObject from './toPlainObject.js';\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n var objValue = safeGet(object, key),\n srcValue = safeGet(source, key),\n stacked = stack.get(srcValue);\n\n if (stacked) {\n assignMergeValue(object, key, stacked);\n return;\n }\n var newValue = customizer\n ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n : undefined;\n\n var isCommon = newValue === undefined;\n\n if (isCommon) {\n var isArr = isArray(srcValue),\n isBuff = !isArr && isBuffer(srcValue),\n isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n newValue = srcValue;\n if (isArr || isBuff || isTyped) {\n if (isArray(objValue)) {\n newValue = objValue;\n }\n else if (isArrayLikeObject(objValue)) {\n newValue = copyArray(objValue);\n }\n else if (isBuff) {\n isCommon = false;\n newValue = cloneBuffer(srcValue, true);\n }\n else if (isTyped) {\n isCommon = false;\n newValue = cloneTypedArray(srcValue, true);\n }\n else {\n newValue = [];\n }\n }\n else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n newValue = objValue;\n if (isArguments(objValue)) {\n newValue = toPlainObject(objValue);\n }\n else if (!isObject(objValue) || isFunction(objValue)) {\n newValue = initCloneObject(srcValue);\n }\n }\n else {\n isCommon = false;\n }\n }\n if (isCommon) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n stack.set(srcValue, newValue);\n mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n stack['delete'](srcValue);\n }\n assignMergeValue(object, key, newValue);\n}\n\nexport default baseMergeDeep;\n","import isArrayLike from './isArrayLike.js';\nimport isObjectLike from './isObjectLike.js';\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n}\n\nexport default isArrayLikeObject;\n","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array || (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n}\n\nexport default copyArray;\n","import baseCreate from './_baseCreate.js';\nimport getPrototype from './_getPrototype.js';\nimport isPrototype from './_isPrototype.js';\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n}\n\nexport default initCloneObject;\n","import Stack from './_Stack.js';\nimport assignMergeValue from './_assignMergeValue.js';\nimport baseFor from './_baseFor.js';\nimport baseMergeDeep from './_baseMergeDeep.js';\nimport isObject from './isObject.js';\nimport keysIn from './keysIn.js';\nimport safeGet from './_safeGet.js';\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n if (object === source) {\n return;\n }\n baseFor(source, function(srcValue, key) {\n stack || (stack = new Stack);\n if (isObject(srcValue)) {\n baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n }\n else {\n var newValue = customizer\n ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n : undefined;\n\n if (newValue === undefined) {\n newValue = srcValue;\n }\n assignMergeValue(object, key, newValue);\n }\n }, keysIn);\n}\n\nexport default baseMerge;\n","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n return value;\n}\n\nexport default identity;\n","import apply from './_apply.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n return function() {\n var args = arguments,\n index = -1,\n length = nativeMax(args.length - start, 0),\n array = Array(length);\n\n while (++index < length) {\n array[index] = args[start + index];\n }\n index = -1;\n var otherArgs = Array(start + 1);\n while (++index < start) {\n otherArgs[index] = args[index];\n }\n otherArgs[start] = transform(array);\n return apply(func, this, otherArgs);\n };\n}\n\nexport default overRest;\n","import constant from './constant.js';\nimport defineProperty from './_defineProperty.js';\nimport identity from './identity.js';\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n return defineProperty(func, 'toString', {\n 'configurable': true,\n 'enumerable': false,\n 'value': constant(string),\n 'writable': true\n });\n};\n\nexport default baseSetToString;\n","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n return function() {\n return value;\n };\n}\n\nexport default constant;\n","/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n var count = 0,\n lastCalled = 0;\n\n return function() {\n var stamp = nativeNow(),\n remaining = HOT_SPAN - (stamp - lastCalled);\n\n lastCalled = stamp;\n if (remaining > 0) {\n if (++count >= HOT_COUNT) {\n return arguments[0];\n }\n } else {\n count = 0;\n }\n return func.apply(undefined, arguments);\n };\n}\n\nexport default shortOut;\n","import baseSetToString from './_baseSetToString.js';\nimport shortOut from './_shortOut.js';\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nexport default setToString;\n","import identity from './identity.js';\nimport overRest from './_overRest.js';\nimport setToString from './_setToString.js';\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n return setToString(overRest(func, start, identity), func + '');\n}\n\nexport default baseRest;\n","/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n switch (args.length) {\n case 0: return func.call(thisArg);\n case 1: return func.call(thisArg, args[0]);\n case 2: return func.call(thisArg, args[0], args[1]);\n case 3: return func.call(thisArg, args[0], args[1], args[2]);\n }\n return func.apply(thisArg, args);\n}\n\nexport default apply;\n","import baseMerge from './_baseMerge.js';\nimport createAssigner from './_createAssigner.js';\n\n/**\n * This method is like `_.merge` except that it accepts `customizer` which\n * is invoked to produce the merged values of the destination and source\n * properties. If `customizer` returns `undefined`, merging is handled by the\n * method instead. The `customizer` is invoked with six arguments:\n * (objValue, srcValue, key, object, source, stack).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function customizer(objValue, srcValue) {\n * if (_.isArray(objValue)) {\n * return objValue.concat(srcValue);\n * }\n * }\n *\n * var object = { 'a': [1], 'b': [2] };\n * var other = { 'a': [3], 'b': [4] };\n *\n * _.mergeWith(object, other, customizer);\n * // => { 'a': [1, 3], 'b': [2, 4] }\n */\nvar mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n baseMerge(object, source, srcIndex, customizer);\n});\n\nexport default mergeWith;\n","import baseRest from './_baseRest.js';\nimport isIterateeCall from './_isIterateeCall.js';\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n return baseRest(function(object, sources) {\n var index = -1,\n length = sources.length,\n customizer = length > 1 ? sources[length - 1] : undefined,\n guard = length > 2 ? sources[2] : undefined;\n\n customizer = (assigner.length > 3 && typeof customizer == 'function')\n ? (length--, customizer)\n : undefined;\n\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n customizer = length < 3 ? undefined : customizer;\n length = 1;\n }\n object = Object(object);\n while (++index < length) {\n var source = sources[index];\n if (source) {\n assigner(object, source, index, customizer);\n }\n }\n return object;\n });\n}\n\nexport default createAssigner;\n","import eq from './eq.js';\nimport isArrayLike from './isArrayLike.js';\nimport isIndex from './_isIndex.js';\nimport isObject from './isObject.js';\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n * else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n if (!isObject(object)) {\n return false;\n }\n var type = typeof index;\n if (type == 'number'\n ? (isArrayLike(object) && isIndex(index, object.length))\n : (type == 'string' && index in object)\n ) {\n return eq(object[index], value);\n }\n return false;\n}\n\nexport default isIterateeCall;\n","import MapCache from './_MapCache.js';\nimport setCacheAdd from './_setCacheAdd.js';\nimport setCacheHas from './_setCacheHas.js';\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n var index = -1,\n length = values == null ? 0 : values.length;\n\n this.__data__ = new MapCache;\n while (++index < length) {\n this.add(values[index]);\n }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nexport default SetCache;\n","/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n */\nfunction arraySome(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (predicate(array[index], index, array)) {\n return true;\n }\n }\n return false;\n}\n\nexport default arraySome;\n","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n this.__data__.set(value, HASH_UNDEFINED);\n return this;\n}\n\nexport default setCacheAdd;\n","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n return this.__data__.has(value);\n}\n\nexport default setCacheHas;\n","import SetCache from './_SetCache.js';\nimport arraySome from './_arraySome.js';\nimport cacheHas from './_cacheHas.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n arrLength = array.length,\n othLength = other.length;\n\n if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n return false;\n }\n // Check that cyclic values are equal.\n var arrStacked = stack.get(array);\n var othStacked = stack.get(other);\n if (arrStacked && othStacked) {\n return arrStacked == other && othStacked == array;\n }\n var index = -1,\n result = true,\n seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n stack.set(array, other);\n stack.set(other, array);\n\n // Ignore non-index properties.\n while (++index < arrLength) {\n var arrValue = array[index],\n othValue = other[index];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, arrValue, index, other, array, stack)\n : customizer(arrValue, othValue, index, array, other, stack);\n }\n if (compared !== undefined) {\n if (compared) {\n continue;\n }\n result = false;\n break;\n }\n // Recursively compare arrays (susceptible to call stack limits).\n if (seen) {\n if (!arraySome(other, function(othValue, othIndex) {\n if (!cacheHas(seen, othIndex) &&\n (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n return seen.push(othIndex);\n }\n })) {\n result = false;\n break;\n }\n } else if (!(\n arrValue === othValue ||\n equalFunc(arrValue, othValue, bitmask, customizer, stack)\n )) {\n result = false;\n break;\n }\n }\n stack['delete'](array);\n stack['delete'](other);\n return result;\n}\n\nexport default equalArrays;\n","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n return cache.has(key);\n}\n\nexport default cacheHas;\n","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n}\n\nexport default mapToArray;\n","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\nexport default setToArray;\n","import Symbol from './_Symbol.js';\nimport Uint8Array from './_Uint8Array.js';\nimport eq from './eq.js';\nimport equalArrays from './_equalArrays.js';\nimport mapToArray from './_mapToArray.js';\nimport setToArray from './_setToArray.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n switch (tag) {\n case dataViewTag:\n if ((object.byteLength != other.byteLength) ||\n (object.byteOffset != other.byteOffset)) {\n return false;\n }\n object = object.buffer;\n other = other.buffer;\n\n case arrayBufferTag:\n if ((object.byteLength != other.byteLength) ||\n !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n return false;\n }\n return true;\n\n case boolTag:\n case dateTag:\n case numberTag:\n // Coerce booleans to `1` or `0` and dates to milliseconds.\n // Invalid dates are coerced to `NaN`.\n return eq(+object, +other);\n\n case errorTag:\n return object.name == other.name && object.message == other.message;\n\n case regexpTag:\n case stringTag:\n // Coerce regexes to strings and treat strings, primitives and objects,\n // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n // for more details.\n return object == (other + '');\n\n case mapTag:\n var convert = mapToArray;\n\n case setTag:\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n convert || (convert = setToArray);\n\n if (object.size != other.size && !isPartial) {\n return false;\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(object);\n if (stacked) {\n return stacked == other;\n }\n bitmask |= COMPARE_UNORDERED_FLAG;\n\n // Recursively compare objects (susceptible to call stack limits).\n stack.set(object, other);\n var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n stack['delete'](object);\n return result;\n\n case symbolTag:\n if (symbolValueOf) {\n return symbolValueOf.call(object) == symbolValueOf.call(other);\n }\n }\n return false;\n}\n\nexport default equalByTag;\n","import arrayFilter from './_arrayFilter.js';\nimport stubArray from './stubArray.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n if (object == null) {\n return [];\n }\n object = Object(object);\n return arrayFilter(nativeGetSymbols(object), function(symbol) {\n return propertyIsEnumerable.call(object, symbol);\n });\n};\n\nexport default getSymbols;\n","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (predicate(value, index, array)) {\n result[resIndex++] = value;\n }\n }\n return result;\n}\n\nexport default arrayFilter;\n","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n return [];\n}\n\nexport default stubArray;\n","import overArg from './_overArg.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nexport default nativeKeys;\n","import isPrototype from './_isPrototype.js';\nimport nativeKeys from './_nativeKeys.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\nexport default baseKeys;\n","import arrayLikeKeys from './_arrayLikeKeys.js';\nimport baseKeys from './_baseKeys.js';\nimport isArrayLike from './isArrayLike.js';\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nexport default keys;\n","import baseGetAllKeys from './_baseGetAllKeys.js';\nimport getSymbols from './_getSymbols.js';\nimport keys from './keys.js';\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n}\n\nexport default getAllKeys;\n","import arrayPush from './_arrayPush.js';\nimport isArray from './isArray.js';\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nexport default baseGetAllKeys;\n","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\nexport default arrayPush;\n","import getAllKeys from './_getAllKeys.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n objProps = getAllKeys(object),\n objLength = objProps.length,\n othProps = getAllKeys(other),\n othLength = othProps.length;\n\n if (objLength != othLength && !isPartial) {\n return false;\n }\n var index = objLength;\n while (index--) {\n var key = objProps[index];\n if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n return false;\n }\n }\n // Check that cyclic values are equal.\n var objStacked = stack.get(object);\n var othStacked = stack.get(other);\n if (objStacked && othStacked) {\n return objStacked == other && othStacked == object;\n }\n var result = true;\n stack.set(object, other);\n stack.set(other, object);\n\n var skipCtor = isPartial;\n while (++index < objLength) {\n key = objProps[index];\n var objValue = object[key],\n othValue = other[key];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, objValue, key, other, object, stack)\n : customizer(objValue, othValue, key, object, other, stack);\n }\n // Recursively compare objects (susceptible to call stack limits).\n if (!(compared === undefined\n ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n : compared\n )) {\n result = false;\n break;\n }\n skipCtor || (skipCtor = key == 'constructor');\n }\n if (result && !skipCtor) {\n var objCtor = object.constructor,\n othCtor = other.constructor;\n\n // Non `Object` object instances with different constructors are not equal.\n if (objCtor != othCtor &&\n ('constructor' in object && 'constructor' in other) &&\n !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n result = false;\n }\n }\n stack['delete'](object);\n stack['delete'](other);\n return result;\n}\n\nexport default equalObjects;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nexport default DataView;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nexport default Promise;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nexport default Set;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nexport default WeakMap;\n","import DataView from './_DataView.js';\nimport Map from './_Map.js';\nimport Promise from './_Promise.js';\nimport Set from './_Set.js';\nimport WeakMap from './_WeakMap.js';\nimport baseGetTag from './_baseGetTag.js';\nimport toSource from './_toSource.js';\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n setTag = '[object Set]',\n weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n (Map && getTag(new Map) != mapTag) ||\n (Promise && getTag(Promise.resolve()) != promiseTag) ||\n (Set && getTag(new Set) != setTag) ||\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = baseGetTag(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : '';\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n}\n\nexport default getTag;\n","import Stack from './_Stack.js';\nimport equalArrays from './_equalArrays.js';\nimport equalByTag from './_equalByTag.js';\nimport equalObjects from './_equalObjects.js';\nimport getTag from './_getTag.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isTypedArray from './isTypedArray.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n var objIsArr = isArray(object),\n othIsArr = isArray(other),\n objTag = objIsArr ? arrayTag : getTag(object),\n othTag = othIsArr ? arrayTag : getTag(other);\n\n objTag = objTag == argsTag ? objectTag : objTag;\n othTag = othTag == argsTag ? objectTag : othTag;\n\n var objIsObj = objTag == objectTag,\n othIsObj = othTag == objectTag,\n isSameTag = objTag == othTag;\n\n if (isSameTag && isBuffer(object)) {\n if (!isBuffer(other)) {\n return false;\n }\n objIsArr = true;\n objIsObj = false;\n }\n if (isSameTag && !objIsObj) {\n stack || (stack = new Stack);\n return (objIsArr || isTypedArray(object))\n ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n }\n if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n if (objIsWrapped || othIsWrapped) {\n var objUnwrapped = objIsWrapped ? object.value() : object,\n othUnwrapped = othIsWrapped ? other.value() : other;\n\n stack || (stack = new Stack);\n return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n }\n }\n if (!isSameTag) {\n return false;\n }\n stack || (stack = new Stack);\n return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\nexport default baseIsEqualDeep;\n","import baseIsEqualDeep from './_baseIsEqualDeep.js';\nimport isObjectLike from './isObjectLike.js';\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Unordered comparison\n * 2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n if (value === other) {\n return true;\n }\n if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n return value !== value && other !== other;\n }\n return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\nexport default baseIsEqual;\n","import baseIsEqual from './_baseIsEqual.js';\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n return baseIsEqual(value, other);\n}\n\nexport default isEqual;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.has` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHas(object, key) {\n return object != null && hasOwnProperty.call(object, key);\n}\n\nexport default baseHas;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nexport default isSymbol;\n","import isArray from './isArray.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n if (isArray(value)) {\n return false;\n }\n var type = typeof value;\n if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n value == null || isSymbol(value)) {\n return true;\n }\n return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n (object != null && value in Object(object));\n}\n\nexport default isKey;\n","import MapCache from './_MapCache.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n var memoized = function() {\n var args = arguments,\n key = resolver ? resolver.apply(this, args) : args[0],\n cache = memoized.cache;\n\n if (cache.has(key)) {\n return cache.get(key);\n }\n var result = func.apply(this, args);\n memoized.cache = cache.set(key, result) || cache;\n return result;\n };\n memoized.cache = new (memoize.Cache || MapCache);\n return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nexport default memoize;\n","import memoizeCapped from './_memoizeCapped.js';\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n var result = [];\n if (string.charCodeAt(0) === 46 /* . */) {\n result.push('');\n }\n string.replace(rePropName, function(match, number, quote, subString) {\n result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n });\n return result;\n});\n\nexport default stringToPath;\n","import memoize from './memoize.js';\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n var result = memoize(func, function(key) {\n if (cache.size === MAX_MEMOIZE_SIZE) {\n cache.clear();\n }\n return key;\n });\n\n var cache = result.cache;\n return result;\n}\n\nexport default memoizeCapped;\n","import Symbol from './_Symbol.js';\nimport arrayMap from './_arrayMap.js';\nimport isArray from './isArray.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n // Exit early for strings to avoid a performance hit in some environments.\n if (typeof value == 'string') {\n return value;\n }\n if (isArray(value)) {\n // Recursively convert values (susceptible to call stack limits).\n return arrayMap(value, baseToString) + '';\n }\n if (isSymbol(value)) {\n return symbolToString ? symbolToString.call(value) : '';\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nexport default baseToString;\n","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length,\n result = Array(length);\n\n while (++index < length) {\n result[index] = iteratee(array[index], index, array);\n }\n return result;\n}\n\nexport default arrayMap;\n","import isArray from './isArray.js';\nimport isKey from './_isKey.js';\nimport stringToPath from './_stringToPath.js';\nimport toString from './toString.js';\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n if (isArray(value)) {\n return value;\n }\n return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nexport default castPath;\n","import baseToString from './_baseToString.js';\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n return value == null ? '' : baseToString(value);\n}\n\nexport default toString;\n","import isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n if (typeof value == 'string' || isSymbol(value)) {\n return value;\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nexport default toKey;\n","import baseHas from './_baseHas.js';\nimport hasPath from './_hasPath.js';\n\n/**\n * Checks if `path` is a direct property of `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = { 'a': { 'b': 2 } };\n * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.has(object, 'a');\n * // => true\n *\n * _.has(object, 'a.b');\n * // => true\n *\n * _.has(object, ['a', 'b']);\n * // => true\n *\n * _.has(other, 'a');\n * // => false\n */\nfunction has(object, path) {\n return object != null && hasPath(object, path, baseHas);\n}\n\nexport default has;\n","import castPath from './_castPath.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isIndex from './_isIndex.js';\nimport isLength from './isLength.js';\nimport toKey from './_toKey.js';\n\n/**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\nfunction hasPath(object, path, hasFunc) {\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n result = false;\n\n while (++index < length) {\n var key = toKey(path[index]);\n if (!(result = object != null && hasFunc(object, key))) {\n break;\n }\n object = object[key];\n }\n if (result || ++index != length) {\n return result;\n }\n length = object == null ? 0 : object.length;\n return !!length && isLength(length) && isIndex(key, length) &&\n (isArray(object) || isArguments(object));\n}\n\nexport default hasPath;\n","import baseGet from './_baseGet.js';\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\nfunction get(object, path, defaultValue) {\n var result = object == null ? undefined : baseGet(object, path);\n return result === undefined ? defaultValue : result;\n}\n\nexport default get;\n","import castPath from './_castPath.js';\nimport toKey from './_toKey.js';\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n path = castPath(path, object);\n\n var index = 0,\n length = path.length;\n\n while (object != null && index < length) {\n object = object[toKey(path[index++])];\n }\n return (index && index == length) ? object : undefined;\n}\n\nexport default baseGet;\n","import baseSet from './_baseSet.js';\n\n/**\n * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n * it's created. Arrays are created for missing index properties while objects\n * are created for all other missing properties. Use `_.setWith` to customize\n * `path` creation.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.set(object, 'a[0].b.c', 4);\n * console.log(object.a[0].b.c);\n * // => 4\n *\n * _.set(object, ['x', '0', 'y', 'z'], 5);\n * console.log(object.x[0].y.z);\n * // => 5\n */\nfunction set(object, path, value) {\n return object == null ? object : baseSet(object, path, value);\n}\n\nexport default set;\n","import assignValue from './_assignValue.js';\nimport castPath from './_castPath.js';\nimport isIndex from './_isIndex.js';\nimport isObject from './isObject.js';\nimport toKey from './_toKey.js';\n\n/**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\nfunction baseSet(object, path, value, customizer) {\n if (!isObject(object)) {\n return object;\n }\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n lastIndex = length - 1,\n nested = object;\n\n while (nested != null && ++index < length) {\n var key = toKey(path[index]),\n newValue = value;\n\n if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n return object;\n }\n\n if (index != lastIndex) {\n var objValue = nested[key];\n newValue = customizer ? customizer(objValue, key, nested) : undefined;\n if (newValue === undefined) {\n newValue = isObject(objValue)\n ? objValue\n : (isIndex(path[index + 1]) ? [] : {});\n }\n }\n assignValue(nested, key, newValue);\n nested = nested[key];\n }\n return object;\n}\n\nexport default baseSet;\n","import castArray from 'lodash-es/castArray';\nimport isFunction from 'lodash-es/isFunction';\nimport isString from 'lodash-es/isString';\nimport type { SubDomainOptions } from './Options';\n\nexport default {\n range: (value: number): number => Math.max(+value, 1),\n 'date.highlight': (args: Date[] | Date): Date[] => castArray(args),\n 'subDomain.label': (\n value: SubDomainOptions['label'],\n ): string | Function | null =>\n // eslint-disable-next-line\n ((isString(value) && value !== '') || isFunction(value) ? value : null),\n};\n","'use strict';\n/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */\n/* eslint-disable regexp/no-useless-quantifier -- testing */\nvar call = require('../internals/function-call');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toString = require('../internals/to-string');\nvar regexpFlags = require('../internals/regexp-flags');\nvar stickyHelpers = require('../internals/regexp-sticky-helpers');\nvar shared = require('../internals/shared');\nvar create = require('../internals/object-create');\nvar getInternalState = require('../internals/internal-state').get;\nvar UNSUPPORTED_DOT_ALL = require('../internals/regexp-unsupported-dot-all');\nvar UNSUPPORTED_NCG = require('../internals/regexp-unsupported-ncg');\n\nvar nativeReplace = shared('native-string-replace', String.prototype.replace);\nvar nativeExec = RegExp.prototype.exec;\nvar patchedExec = nativeExec;\nvar charAt = uncurryThis(''.charAt);\nvar indexOf = uncurryThis(''.indexOf);\nvar replace = uncurryThis(''.replace);\nvar stringSlice = uncurryThis(''.slice);\n\nvar UPDATES_LAST_INDEX_WRONG = (function () {\n var re1 = /a/;\n var re2 = /b*/g;\n call(nativeExec, re1, 'a');\n call(nativeExec, re2, 'a');\n return re1.lastIndex !== 0 || re2.lastIndex !== 0;\n})();\n\nvar UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;\n\n// nonparticipating capturing group, copied from es5-shim's String#split patch.\nvar NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;\n\nvar PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;\n\nif (PATCH) {\n patchedExec = function exec(string) {\n var re = this;\n var state = getInternalState(re);\n var str = toString(string);\n var raw = state.raw;\n var result, reCopy, lastIndex, match, i, object, group;\n\n if (raw) {\n raw.lastIndex = re.lastIndex;\n result = call(patchedExec, raw, str);\n re.lastIndex = raw.lastIndex;\n return result;\n }\n\n var groups = state.groups;\n var sticky = UNSUPPORTED_Y && re.sticky;\n var flags = call(regexpFlags, re);\n var source = re.source;\n var charsAdded = 0;\n var strCopy = str;\n\n if (sticky) {\n flags = replace(flags, 'y', '');\n if (indexOf(flags, 'g') === -1) {\n flags += 'g';\n }\n\n strCopy = stringSlice(str, re.lastIndex);\n // Support anchored sticky behavior.\n if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt(str, re.lastIndex - 1) !== '\\n')) {\n source = '(?: ' + source + ')';\n strCopy = ' ' + strCopy;\n charsAdded++;\n }\n // ^(? + rx + ) is needed, in combination with some str slicing, to\n // simulate the 'y' flag.\n reCopy = new RegExp('^(?:' + source + ')', flags);\n }\n\n if (NPCG_INCLUDED) {\n reCopy = new RegExp('^' + source + '$(?!\\\\s)', flags);\n }\n if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;\n\n match = call(nativeExec, sticky ? reCopy : re, strCopy);\n\n if (sticky) {\n if (match) {\n match.input = stringSlice(match.input, charsAdded);\n match[0] = stringSlice(match[0], charsAdded);\n match.index = re.lastIndex;\n re.lastIndex += match[0].length;\n } else re.lastIndex = 0;\n } else if (UPDATES_LAST_INDEX_WRONG && match) {\n re.lastIndex = re.global ? match.index + match[0].length : lastIndex;\n }\n if (NPCG_INCLUDED && match && match.length > 1) {\n // Fix browsers whose `exec` methods don't consistently return `undefined`\n // for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/\n call(nativeReplace, match[0], reCopy, function () {\n for (i = 1; i < arguments.length - 2; i++) {\n if (arguments[i] === undefined) match[i] = undefined;\n }\n });\n }\n\n if (match && groups) {\n match.groups = object = create(null);\n for (i = 0; i < groups.length; i++) {\n group = groups[i];\n object[group[0]] = match[group[1]];\n }\n }\n\n return match;\n };\n}\n\nmodule.exports = patchedExec;\n","import baseGetTag from './_baseGetTag.js';\nimport isArray from './isArray.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar stringTag = '[object String]';\n\n/**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\nfunction isString(value) {\n return typeof value == 'string' ||\n (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n}\n\nexport default isString;\n","import mergeWith from 'lodash-es/mergeWith';\nimport isEqual from 'lodash-es/isEqual';\nimport has from 'lodash-es/has';\nimport get from 'lodash-es/get';\nimport set from 'lodash-es/set';\nimport type { Ls } from 'dayjs';\nimport type { DomainType, Timestamp } from '../index';\nimport {\n OPTIONS_DEFAULT_DOMAIN_TYPE,\n OPTIONS_DEFAULT_SUBDOMAIN_TYPE,\n OPTIONS_DEFAULT_SUBDOMAIN_WIDTH,\n OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT,\n OPTIONS_DEFAULT_SUBDOMAIN_GUTTER,\n OPTIONS_DEFAULT_SUBDOMAIN_RADIUS,\n OPTIONS_DEFAULT_THEME,\n OPTIONS_DEFAULT_ANIMATION_DURATION,\n OPTIONS_DEFAULT_ITEM_SELECTOR,\n OPTIONS_DEFAULT_RANGE,\n SCALE_BASE_COLOR_SCHEME,\n SCALE_BASE_COLOR_TYPE,\n SCALE_BASE_COLOR_DOMAIN,\n OPTIONS_DEFAULT_LOCALE,\n} from '../constant';\n\nimport OptionsPreProcessors from './OptionsPreProcessors';\n\ntype SortOrder = 'asc' | 'desc';\nexport type TextAlign = 'start' | 'middle' | 'end';\nexport type Padding = [number, number, number, number];\n\nexport type DomainOptions = {\n type: DomainType;\n gutter: number;\n padding: Padding;\n dynamicDimension: boolean;\n label: LabelOptions;\n sort: SortOrder;\n};\n\ntype LabelOptions = {\n text?:\n | string\n | null\n | ((timestamp: Timestamp, element: SVGElement) => string);\n position: 'top' | 'right' | 'bottom' | 'left';\n textAlign: TextAlign;\n offset: {\n x: number;\n y: number;\n };\n rotate: null | 'left' | 'right';\n width: number;\n height: number;\n};\n\nexport type SubDomainOptions = {\n type: string;\n width: number;\n height: number;\n gutter: number;\n radius: number;\n label:\n | string\n | null\n | ((timestamp: Timestamp, value: number, element: SVGElement) => string);\n color?:\n | string\n | ((\n timestamp: Timestamp,\n value: number | string | null | undefined,\n backgroundColor: string,\n ) => string);\n sort: SortOrder;\n};\n\nexport type DataGroupType = 'sum' | 'count' | 'min' | 'max' | 'average';\n\ntype DateOptions = {\n start: Date;\n min?: Date;\n max?: Date;\n highlight: Date[];\n locale: string | Partial<(typeof Ls)[0]>;\n timezone?: string;\n};\n\nexport type DataRecord = Record;\nexport type DataOptions = {\n source: string | DataRecord[];\n type: 'json' | 'csv' | 'tsv' | 'txt';\n requestInit: object;\n x: string | ((datum: DataRecord) => number);\n y: string | ((datum: DataRecord) => number);\n groupY:\n | DataGroupType\n | ((values: (string | number | null)[]) => string | number | null);\n defaultValue: null | number | string;\n};\n\ntype ScaleOptions = {\n opacity?: {\n domain: number[];\n type?: string;\n baseColor: string;\n };\n color?: {\n domain: number[];\n scheme?: string;\n range?: string[];\n interpolate?: any;\n type?: string;\n };\n};\n\nexport type OptionsType = {\n itemSelector: string;\n range: number;\n domain: DomainOptions;\n subDomain: SubDomainOptions;\n date: DateOptions;\n data: DataOptions;\n scale?: ScaleOptions;\n animationDuration: number;\n verticalOrientation: boolean;\n theme: 'light' | 'dark';\n};\n\ntype InternalOptionsType = {\n x: {\n domainHorizontalLabelWidth: number;\n domainVerticalLabelHeight: number;\n };\n};\n\nexport default class Options {\n options: OptionsType & InternalOptionsType;\n\n preProcessors: {\n [key: string]: (value: any) => any;\n };\n\n constructor(processors = OptionsPreProcessors) {\n this.preProcessors = processors;\n\n this.options = {\n // selector string of the container to append the graph to\n // Accept any string value accepted by document.querySelector or CSS3\n // or an Element object\n itemSelector: OPTIONS_DEFAULT_ITEM_SELECTOR,\n\n // Number of domain to display on the graph\n range: OPTIONS_DEFAULT_RANGE,\n\n domain: {\n type: OPTIONS_DEFAULT_DOMAIN_TYPE,\n\n // Space between each domain, in pixel\n gutter: 4,\n\n padding: [0, 0, 0, 0],\n\n // Whether to enable dynamic domain size\n // The width/height on a domain depends on the number of\n // subDomains items count\n dynamicDimension: true,\n\n // Whether to show most recent date first\n sort: 'asc',\n\n label: {\n // Formatting of the domain label\n // @default: undefined, will use the formatting\n // according to domain type\n // Accept any string accepted by dayjs.format()\n // or a function\n //\n // Refer to https://day.js.org/docs/en/display/format\n // for list of accepted string tokens used by dayjs.format()\n text: undefined,\n\n // valid: top, right, bottom, left\n position: 'bottom',\n\n // Valid are the direct svg values: start, middle, end\n textAlign: 'middle',\n\n // By default, there is no margin/padding around the label\n offset: {\n x: 0,\n y: 0,\n },\n\n rotate: null,\n\n // Used only on vertical orientation\n width: 100,\n\n // Used only on horizontal orientation\n height: 25,\n },\n },\n\n subDomain: {\n type: OPTIONS_DEFAULT_SUBDOMAIN_TYPE,\n\n // Width of each subDomain cell, in pixel\n width: OPTIONS_DEFAULT_SUBDOMAIN_WIDTH,\n\n // Height of each subDomain cell, in pixel\n height: OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT,\n\n // Space between each subDomain cell, in pixel\n gutter: OPTIONS_DEFAULT_SUBDOMAIN_GUTTER,\n\n // Radius of each subDomain cell, in pixel\n radius: OPTIONS_DEFAULT_SUBDOMAIN_RADIUS,\n\n // Formatting of the text inside each subDomain cell\n // @default: null, no text\n // Accept any string accepted by dayjs.format()\n // or a function\n //\n // Refer to https://day.js.org/docs/en/display/format\n // for list of accepted string tokens used by dayjs.format()\n label: null,\n\n color: undefined,\n\n sort: 'asc',\n },\n\n date: {\n // Start date of the graph\n // @default now\n start: new Date(),\n\n min: undefined,\n\n max: undefined,\n\n // List of dates to highlight\n // Valid values:\n // - []: don't highlight anything\n // - an array of Date objects: highlight the specified dates\n highlight: [],\n\n locale: OPTIONS_DEFAULT_LOCALE,\n\n timezone: undefined,\n },\n\n // Calendar orientation\n // false: display domains side by side\n // true : display domains one under the other\n verticalOrientation: false,\n\n data: {\n // Data source\n // URL, where to fetch the original datas\n source: '',\n\n // Data type\n // Default: json\n type: 'json',\n\n requestInit: {},\n\n // keyname of the time property\n x: '',\n\n // keyname of the value property\n y: '',\n\n // Grouping function of the values\n groupY: 'sum',\n\n defaultValue: null,\n },\n\n scale: undefined,\n\n // Animation duration, in ms\n animationDuration: OPTIONS_DEFAULT_ANIMATION_DURATION,\n\n // Theme mode: dark/light\n theme: OPTIONS_DEFAULT_THEME,\n\n // Internally used options, do not edit not set\n x: {\n domainHorizontalLabelWidth: 0,\n domainVerticalLabelHeight: 0,\n },\n };\n }\n\n /**\n * Set a new value for an option, only if unchanged\n * @param {string} key Name of the option\n * @param {any} value Value of the option\n * @return {boolean} Whether the option have been changed\n */\n set(key: string, value: any): boolean {\n if (!has(this.options, key) || isEqual(get(this.options, key), value)) {\n return false;\n }\n\n set(\n this.options,\n key,\n has(this.preProcessors, key) ?\n get(this.preProcessors, key)(value) :\n value,\n );\n\n return true;\n }\n\n init(opts?: CalHeatmap.DeepPartial): void {\n this.options = {\n // eslint-disable-next-line arrow-body-style\n ...mergeWith(this.options, opts, (_, srcValue) => {\n return Array.isArray(srcValue) ? srcValue : undefined;\n }),\n };\n\n const { options } = this;\n\n Object.keys(this.preProcessors).forEach((key) => {\n set(options, key, get(this.preProcessors, key)(get(options, key)));\n });\n\n if (typeof options.scale === 'undefined') {\n this.initScale();\n }\n\n options.x.domainVerticalLabelHeight = options.domain.label.height;\n\n // When the label is affecting the height\n if (\n options.domain.label.position === 'top' ||\n options.domain.label.position === 'bottom'\n ) {\n options.x.domainHorizontalLabelWidth = 0;\n } else {\n options.x.domainVerticalLabelHeight = 0;\n options.x.domainHorizontalLabelWidth = options.domain.label.width;\n }\n\n if (\n options.domain.label.text === null ||\n options.domain.label.text === ''\n ) {\n options.x.domainVerticalLabelHeight = 0;\n options.x.domainHorizontalLabelWidth = 0;\n }\n }\n\n initScale() {\n this.options.scale = {\n color: {\n scheme: SCALE_BASE_COLOR_SCHEME,\n type: SCALE_BASE_COLOR_TYPE,\n domain: SCALE_BASE_COLOR_DOMAIN,\n },\n };\n }\n}\n","'use strict';\nvar anObject = require('../internals/an-object');\n\n// `RegExp.prototype.flags` getter implementation\n// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags\nmodule.exports = function () {\n var that = anObject(this);\n var result = '';\n if (that.hasIndices) result += 'd';\n if (that.global) result += 'g';\n if (that.ignoreCase) result += 'i';\n if (that.multiline) result += 'm';\n if (that.dotAll) result += 's';\n if (that.unicode) result += 'u';\n if (that.unicodeSets) result += 'v';\n if (that.sticky) result += 'y';\n return result;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\n// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError\nvar $RegExp = global.RegExp;\n\nvar UNSUPPORTED_Y = fails(function () {\n var re = $RegExp('a', 'y');\n re.lastIndex = 2;\n return re.exec('abcd') !== null;\n});\n\n// UC Browser bug\n// https://github.com/zloirock/core-js/issues/1008\nvar MISSED_STICKY = UNSUPPORTED_Y || fails(function () {\n return !$RegExp('a', 'y').sticky;\n});\n\nvar BROKEN_CARET = UNSUPPORTED_Y || fails(function () {\n // https://bugzilla.mozilla.org/show_bug.cgi?id=773687\n var re = $RegExp('^r', 'gy');\n re.lastIndex = 2;\n return re.exec('str') !== null;\n});\n\nmodule.exports = {\n BROKEN_CARET: BROKEN_CARET,\n MISSED_STICKY: MISSED_STICKY,\n UNSUPPORTED_Y: UNSUPPORTED_Y\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\n// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError\nvar $RegExp = global.RegExp;\n\nmodule.exports = fails(function () {\n var re = $RegExp('.', 's');\n return !(re.dotAll && re.test('\\n') && re.flags === 's');\n});\n","'use strict';\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\n// babel-minify and Closure Compiler transpiles RegExp('(?b)', 'g') -> /(?b)/g and it causes SyntaxError\nvar $RegExp = global.RegExp;\n\nmodule.exports = fails(function () {\n var re = $RegExp('(?b)', 'g');\n return re.exec('b').groups.a !== 'b' ||\n 'b'.replace(re, '$c') !== 'bc';\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar exec = require('../internals/regexp-exec');\n\n// `RegExp.prototype.exec` method\n// https://tc39.es/ecma262/#sec-regexp.prototype.exec\n$({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {\n exec: exec\n});\n","'use strict';\n// TODO: Remove from `core-js@4` since it's moved to entry points\nrequire('../modules/es.regexp.exec');\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar regexpExec = require('../internals/regexp-exec');\nvar fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar SPECIES = wellKnownSymbol('species');\nvar RegExpPrototype = RegExp.prototype;\n\nmodule.exports = function (KEY, exec, FORCED, SHAM) {\n var SYMBOL = wellKnownSymbol(KEY);\n\n var DELEGATES_TO_SYMBOL = !fails(function () {\n // String methods call symbol-named RegEp methods\n var O = {};\n O[SYMBOL] = function () { return 7; };\n return ''[KEY](O) !== 7;\n });\n\n var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {\n // Symbol-named RegExp methods call .exec\n var execCalled = false;\n var re = /a/;\n\n if (KEY === 'split') {\n // We can't use real regex here since it causes deoptimization\n // and serious performance degradation in V8\n // https://github.com/zloirock/core-js/issues/306\n re = {};\n // RegExp[@@split] doesn't call the regex's exec method, but first creates\n // a new one. We need to return the patched regex when creating the new one.\n re.constructor = {};\n re.constructor[SPECIES] = function () { return re; };\n re.flags = '';\n re[SYMBOL] = /./[SYMBOL];\n }\n\n re.exec = function () {\n execCalled = true;\n return null;\n };\n\n re[SYMBOL]('');\n return !execCalled;\n });\n\n if (\n !DELEGATES_TO_SYMBOL ||\n !DELEGATES_TO_EXEC ||\n FORCED\n ) {\n var uncurriedNativeRegExpMethod = uncurryThis(/./[SYMBOL]);\n var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {\n var uncurriedNativeMethod = uncurryThis(nativeMethod);\n var $exec = regexp.exec;\n if ($exec === regexpExec || $exec === RegExpPrototype.exec) {\n if (DELEGATES_TO_SYMBOL && !forceStringMethod) {\n // The native String method already delegates to @@method (this\n // polyfilled function), leasing to infinite recursion.\n // We avoid it by directly calling the native @@method method.\n return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) };\n }\n return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) };\n }\n return { done: false };\n });\n\n defineBuiltIn(String.prototype, KEY, methods[0]);\n defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]);\n }\n\n if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\n\n// `AdvanceStringIndex` abstract operation\n// https://tc39.es/ecma262/#sec-advancestringindex\nmodule.exports = function (S, index, unicode) {\n return index + (unicode ? charAt(S, index).length : 1);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar floor = Math.floor;\nvar charAt = uncurryThis(''.charAt);\nvar replace = uncurryThis(''.replace);\nvar stringSlice = uncurryThis(''.slice);\n// eslint-disable-next-line redos/no-vulnerable -- safe\nvar SUBSTITUTION_SYMBOLS = /\\$([$&'`]|\\d{1,2}|<[^>]*>)/g;\nvar SUBSTITUTION_SYMBOLS_NO_NAMED = /\\$([$&'`]|\\d{1,2})/g;\n\n// `GetSubstitution` abstract operation\n// https://tc39.es/ecma262/#sec-getsubstitution\nmodule.exports = function (matched, str, position, captures, namedCaptures, replacement) {\n var tailPos = position + matched.length;\n var m = captures.length;\n var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;\n if (namedCaptures !== undefined) {\n namedCaptures = toObject(namedCaptures);\n symbols = SUBSTITUTION_SYMBOLS;\n }\n return replace(replacement, symbols, function (match, ch) {\n var capture;\n switch (charAt(ch, 0)) {\n case '$': return '$';\n case '&': return matched;\n case '`': return stringSlice(str, 0, position);\n case \"'\": return stringSlice(str, tailPos);\n case '<':\n capture = namedCaptures[stringSlice(ch, 1, -1)];\n break;\n default: // \\d\\d?\n var n = +ch;\n if (n === 0) return match;\n if (n > m) {\n var f = floor(n / 10);\n if (f === 0) return match;\n if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1);\n return match;\n }\n capture = captures[n - 1];\n }\n return capture === undefined ? '' : capture;\n });\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof-raw');\nvar regexpExec = require('../internals/regexp-exec');\n\nvar $TypeError = TypeError;\n\n// `RegExpExec` abstract operation\n// https://tc39.es/ecma262/#sec-regexpexec\nmodule.exports = function (R, S) {\n var exec = R.exec;\n if (isCallable(exec)) {\n var result = call(exec, R, S);\n if (result !== null) anObject(result);\n return result;\n }\n if (classof(R) === 'RegExp') return call(regexpExec, R, S);\n throw new $TypeError('RegExp#exec called on incompatible receiver');\n};\n","'use strict';\nvar apply = require('../internals/function-apply');\nvar call = require('../internals/function-call');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');\nvar fails = require('../internals/fails');\nvar anObject = require('../internals/an-object');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toLength = require('../internals/to-length');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar advanceStringIndex = require('../internals/advance-string-index');\nvar getMethod = require('../internals/get-method');\nvar getSubstitution = require('../internals/get-substitution');\nvar regExpExec = require('../internals/regexp-exec-abstract');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar REPLACE = wellKnownSymbol('replace');\nvar max = Math.max;\nvar min = Math.min;\nvar concat = uncurryThis([].concat);\nvar push = uncurryThis([].push);\nvar stringIndexOf = uncurryThis(''.indexOf);\nvar stringSlice = uncurryThis(''.slice);\n\nvar maybeToString = function (it) {\n return it === undefined ? it : String(it);\n};\n\n// IE <= 11 replaces $0 with the whole match, as if it was $&\n// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0\nvar REPLACE_KEEPS_$0 = (function () {\n // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing\n return 'a'.replace(/./, '$0') === '$0';\n})();\n\n// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string\nvar REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {\n if (/./[REPLACE]) {\n return /./[REPLACE]('a', '$0') === '';\n }\n return false;\n})();\n\nvar REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {\n var re = /./;\n re.exec = function () {\n var result = [];\n result.groups = { a: '7' };\n return result;\n };\n // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive\n return ''.replace(re, '$') !== '7';\n});\n\n// @@replace logic\nfixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {\n var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';\n\n return [\n // `String.prototype.replace` method\n // https://tc39.es/ecma262/#sec-string.prototype.replace\n function replace(searchValue, replaceValue) {\n var O = requireObjectCoercible(this);\n var replacer = isNullOrUndefined(searchValue) ? undefined : getMethod(searchValue, REPLACE);\n return replacer\n ? call(replacer, searchValue, O, replaceValue)\n : call(nativeReplace, toString(O), searchValue, replaceValue);\n },\n // `RegExp.prototype[@@replace]` method\n // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace\n function (string, replaceValue) {\n var rx = anObject(this);\n var S = toString(string);\n\n if (\n typeof replaceValue == 'string' &&\n stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 &&\n stringIndexOf(replaceValue, '$<') === -1\n ) {\n var res = maybeCallNative(nativeReplace, rx, S, replaceValue);\n if (res.done) return res.value;\n }\n\n var functionalReplace = isCallable(replaceValue);\n if (!functionalReplace) replaceValue = toString(replaceValue);\n\n var global = rx.global;\n var fullUnicode;\n if (global) {\n fullUnicode = rx.unicode;\n rx.lastIndex = 0;\n }\n\n var results = [];\n var result;\n while (true) {\n result = regExpExec(rx, S);\n if (result === null) break;\n\n push(results, result);\n if (!global) break;\n\n var matchStr = toString(result[0]);\n if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);\n }\n\n var accumulatedResult = '';\n var nextSourcePosition = 0;\n for (var i = 0; i < results.length; i++) {\n result = results[i];\n\n var matched = toString(result[0]);\n var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);\n var captures = [];\n var replacement;\n // NOTE: This is equivalent to\n // captures = result.slice(1).map(maybeToString)\n // but for some reason `nativeSlice.call(result, 1, result.length)` (called in\n // the slice polyfill when slicing native arrays) \"doesn't work\" in safari 9 and\n // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.\n for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));\n var namedCaptures = result.groups;\n if (functionalReplace) {\n var replacerArgs = concat([matched], captures, position, S);\n if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);\n replacement = toString(apply(replaceValue, undefined, replacerArgs));\n } else {\n replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);\n }\n if (position >= nextSourcePosition) {\n accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;\n nextSourcePosition = position + matched.length;\n }\n }\n\n return accumulatedResult + stringSlice(S, nextSourcePosition);\n }\n ];\n}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);\n","import {\n json, csv, dsv, text,\n} from 'd3-fetch';\n\nimport type { DataOptions, DataRecord } from './options/Options';\nimport type { Timestamp } from './index';\nimport type CalHeatmap from './CalHeatmap';\n\nexport default class DataFetcher {\n calendar: CalHeatmap;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n }\n\n /**\n * Fetch and interpret data from the datasource\n *\n * @param {string|object} source\n * @param {number} startTimestamp\n * @param {number} endTimestamp\n *\n * @return {Promize} A promise, that will return the final data when resolved\n */\n async getDatas(\n source: DataOptions['source'],\n startTimestamp: Timestamp,\n endTimestamp: Timestamp,\n ): Promise {\n if (typeof source === 'string' && source.length > 0) {\n return this.#fetch(source, startTimestamp, endTimestamp);\n }\n\n let d: DataRecord[] = [];\n if (Array.isArray(source)) {\n d = source;\n }\n\n return new Promise((resolve) => {\n resolve(d);\n });\n }\n\n parseURI(\n str: string,\n startTimestamp: Timestamp,\n endTimestamp: Timestamp,\n ): string {\n let newUri = str.replace(/\\{\\{start=(.*?)\\}\\}/g, (_, format) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.calendar.dateHelper.date(startTimestamp).format(format));\n newUri = newUri.replace(/\\{\\{end=(.*?)\\}\\}/g, (_, format) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.calendar.dateHelper.date(endTimestamp).format(format));\n\n return newUri;\n }\n\n #fetch(\n source: DataOptions['source'],\n startTimestamp: Timestamp,\n endTimestamp: Timestamp,\n ): Promise {\n const { type, requestInit } = this.calendar.options.options.data;\n\n const url = this.parseURI(source as string, startTimestamp, endTimestamp);\n\n switch (type) {\n case 'json':\n return json(url, requestInit);\n case 'csv':\n return csv(url, requestInit);\n case 'tsv':\n return dsv('\\t', url, requestInit);\n case 'txt':\n return text(url, requestInit);\n default:\n return new Promise((resolve) => {\n resolve([]);\n });\n }\n }\n}\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar FUNCTION_NAME_EXISTS = require('../internals/function-name').EXISTS;\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\n\nvar FunctionPrototype = Function.prototype;\nvar functionToString = uncurryThis(FunctionPrototype.toString);\nvar nameRE = /function\\b(?:\\s|\\/\\*[\\S\\s]*?\\*\\/|\\/\\/[^\\n\\r]*[\\n\\r]+)*([^\\s(/]*)/;\nvar regExpExec = uncurryThis(nameRE.exec);\nvar NAME = 'name';\n\n// Function instances `.name` property\n// https://tc39.es/ecma262/#sec-function-instances-name\nif (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {\n defineBuiltInAccessor(FunctionPrototype, NAME, {\n configurable: true,\n get: function () {\n try {\n return regExpExec(nameRE, functionToString(this))[1];\n } catch (error) {\n return '';\n }\n }\n });\n}\n","!function(t,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(t=\"undefined\"!=typeof globalThis?globalThis:t||self).dayjs=e()}(this,(function(){\"use strict\";var t=1e3,e=6e4,n=36e5,r=\"millisecond\",i=\"second\",s=\"minute\",u=\"hour\",a=\"day\",o=\"week\",c=\"month\",f=\"quarter\",h=\"year\",d=\"date\",l=\"Invalid Date\",$=/^(\\d{4})[-/]?(\\d{1,2})?[-/]?(\\d{0,2})[Tt\\s]*(\\d{1,2})?:?(\\d{1,2})?:?(\\d{1,2})?[.:]?(\\d+)?$/,y=/\\[([^\\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:\"en\",weekdays:\"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday\".split(\"_\"),months:\"January_February_March_April_May_June_July_August_September_October_November_December\".split(\"_\"),ordinal:function(t){var e=[\"th\",\"st\",\"nd\",\"rd\"],n=t%100;return\"[\"+t+(e[(n-20)%10]||e[n]||e[0])+\"]\"}},m=function(t,e,n){var r=String(t);return!r||r.length>=e?t:\"\"+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?\"+\":\"-\")+m(r,2,\"0\")+\":\"+m(i,2,\"0\")},m:function t(e,n){if(e.date()1)return t(u[0])}else{var a=e.name;D[a]=e,i=a}return!r&&i&&(g=i),i||!r&&g},O=function(t,e){if(S(t))return t.clone();var n=\"object\"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},b=v;b.l=w,b.i=S,b.w=function(t,e){return O(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=w(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[p]=!0}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(b.u(e))return new Date;if(e instanceof Date)return new Date(e);if(\"string\"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||\"0\").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.init()},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},m.$utils=function(){return b},m.isValid=function(){return!(this.$d.toString()===l)},m.isSame=function(t,e){var n=O(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return O(t)25){var f=r(this).startOf(t).add(1,t).date(n),s=r(this).endOf(e);if(f.isBefore(s))return 1}var a=r(this).startOf(t).date(n).startOf(e).subtract(1,\"millisecond\"),o=this.diff(a,e,!0);return o<0?r(this).startOf(\"week\").week():Math.ceil(o)},f.weeks=function(e){return void 0===e&&(e=null),this.week(e)}}}));","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_dayOfYear=t()}(this,(function(){\"use strict\";return function(e,t,n){t.prototype.dayOfYear=function(e){var t=Math.round((n(this).startOf(\"day\")-n(this).startOf(\"year\"))/864e5)+1;return null==e?t:this.add(e-t,\"day\")}}}));","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_weekday=t()}(this,(function(){\"use strict\";return function(e,t){t.prototype.weekday=function(e){var t=this.$locale().weekStart||0,i=this.$W,n=(i0&&(n=n[0]);t=(n=n.filter((function(e){return e})))[0];for(var i=1;i4&&(o+=7),n.add(o,e));return r.diff(u,\"week\")+1},d.isoWeekday=function(e){return this.$utils().u(e)?this.day()||7:this.day(this.day()%7?e:e-7)};var n=d.startOf;d.startOf=function(e,t){var i=this.$utils(),s=!!i.u(t)||t;return\"isoweek\"===i.p(e)?s?this.date(this.date()-(this.isoWeekday()-1)).startOf(\"day\"):this.date(this.date()-1-(this.isoWeekday()-1)+7).endOf(\"day\"):n.bind(this)(e,t)}}}));","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_isLeapYear=t()}(this,(function(){\"use strict\";return function(e,t){t.prototype.isLeapYear=function(){return this.$y%4==0&&this.$y%100!=0||this.$y%400==0}}}));","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_advancedFormat=t()}(this,(function(){\"use strict\";return function(e,t){var r=t.prototype,n=r.format;r.format=function(e){var t=this,r=this.$locale();if(!this.isValid())return n.bind(this)(e);var s=this.$utils(),a=(e||\"YYYY-MM-DDTHH:mm:ssZ\").replace(/\\[([^\\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g,(function(e){switch(e){case\"Q\":return Math.ceil((t.$M+1)/3);case\"Do\":return r.ordinal(t.$D);case\"gggg\":return t.weekYear();case\"GGGG\":return t.isoWeekYear();case\"wo\":return r.ordinal(t.week(),\"W\");case\"w\":case\"ww\":return s.s(t.week(),\"w\"===e?1:2,\"0\");case\"W\":case\"WW\":return s.s(t.isoWeek(),\"W\"===e?1:2,\"0\");case\"k\":case\"kk\":return s.s(String(0===t.$H?24:t.$H),\"k\"===e?1:2,\"0\");case\"X\":return Math.floor(t.$d.getTime()/1e3);case\"x\":return t.$d.getTime();case\"z\":return\"[\"+t.offsetName()+\"]\";case\"zzz\":return\"[\"+t.offsetName(\"long\")+\"]\";default:return e}}));return n.bind(this)(a)}}}));","!function(t,i){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=i():\"function\"==typeof define&&define.amd?define(i):(t=\"undefined\"!=typeof globalThis?globalThis:t||self).dayjs_plugin_utc=i()}(this,(function(){\"use strict\";var t=\"minute\",i=/[+-]\\d\\d(?::?\\d\\d)?/g,e=/([+-]|\\d\\d)/g;return function(s,f,n){var u=f.prototype;n.utc=function(t){var i={date:t,utc:!0,args:arguments};return new f(i)},u.utc=function(i){var e=n(this.toDate(),{locale:this.$L,utc:!0});return i?e.add(this.utcOffset(),t):e},u.local=function(){return n(this.toDate(),{locale:this.$L,utc:!1})};var o=u.parse;u.parse=function(t){t.utc&&(this.$u=!0),this.$utils().u(t.$offset)||(this.$offset=t.$offset),o.call(this,t)};var r=u.init;u.init=function(){if(this.$u){var t=this.$d;this.$y=t.getUTCFullYear(),this.$M=t.getUTCMonth(),this.$D=t.getUTCDate(),this.$W=t.getUTCDay(),this.$H=t.getUTCHours(),this.$m=t.getUTCMinutes(),this.$s=t.getUTCSeconds(),this.$ms=t.getUTCMilliseconds()}else r.call(this)};var a=u.utcOffset;u.utcOffset=function(s,f){var n=this.$utils().u;if(n(s))return this.$u?0:n(this.$offset)?a.call(this):this.$offset;if(\"string\"==typeof s&&(s=function(t){void 0===t&&(t=\"\");var s=t.match(i);if(!s)return null;var f=(\"\"+s[0]).match(e)||[\"-\",0,0],n=f[0],u=60*+f[1]+ +f[2];return 0===u?0:\"+\"===n?u:-u}(s),null===s))return this;var u=Math.abs(s)<=16?60*s:s,o=this;if(f)return o.$offset=u,o.$u=0===s,o;if(0!==s){var r=this.$u?this.toDate().getTimezoneOffset():-1*this.utcOffset();(o=this.local().add(u+r,t)).$offset=u,o.$x.$localOffset=r}else o=this.utc();return o};var h=u.format;u.format=function(t){var i=t||(this.$u?\"YYYY-MM-DDTHH:mm:ss[Z]\":\"\");return h.call(this,i)},u.valueOf=function(){var t=this.$utils().u(this.$offset)?0:this.$offset+(this.$x.$localOffset||this.$d.getTimezoneOffset());return this.$d.valueOf()-6e4*t},u.isUTC=function(){return!!this.$u},u.toISOString=function(){return this.toDate().toISOString()},u.toString=function(){return this.toDate().toUTCString()};var l=u.toDate;u.toDate=function(t){return\"s\"===t&&this.$offset?n(this.format(\"YYYY-MM-DD HH:mm:ss:SSS\")).toDate():l.call(this)};var c=u.diff;u.diff=function(t,i,e){if(t&&this.$u===t.$u)return c.call(this,t,i,e);var s=this.local(),f=n(t).local();return c.call(s,f,i,e)}}}));","!function(t,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(t=\"undefined\"!=typeof globalThis?globalThis:t||self).dayjs_plugin_timezone=e()}(this,(function(){\"use strict\";var t={year:0,month:1,day:2,hour:3,minute:4,second:5},e={};return function(n,i,o){var r,a=function(t,n,i){void 0===i&&(i={});var o=new Date(t),r=function(t,n){void 0===n&&(n={});var i=n.timeZoneName||\"short\",o=t+\"|\"+i,r=e[o];return r||(r=new Intl.DateTimeFormat(\"en-US\",{hour12:!1,timeZone:t,year:\"numeric\",month:\"2-digit\",day:\"2-digit\",hour:\"2-digit\",minute:\"2-digit\",second:\"2-digit\",timeZoneName:i}),e[o]=r),r}(n,i);return r.formatToParts(o)},u=function(e,n){for(var i=a(e,n),r=[],u=0;u=0&&(r[c]=parseInt(m,10))}var d=r[3],l=24===d?0:d,h=r[0]+\"-\"+r[1]+\"-\"+r[2]+\" \"+l+\":\"+r[4]+\":\"+r[5]+\":000\",v=+e;return(o.utc(h).valueOf()-(v-=v%1e3))/6e4},f=i.prototype;f.tz=function(t,e){void 0===t&&(t=r);var n=this.utcOffset(),i=this.toDate(),a=i.toLocaleString(\"en-US\",{timeZone:t}),u=Math.round((i-new Date(a))/1e3/60),f=o(a,{locale:this.$L}).$set(\"millisecond\",this.$ms).utcOffset(15*-Math.round(i.getTimezoneOffset()/15)-u,!0);if(e){var s=f.utcOffset();f=f.add(n-s,\"minute\")}return f.$x.$timezone=t,f},f.offsetName=function(t){var e=this.$x.$timezone||o.tz.guess(),n=a(this.valueOf(),e,{timeZoneName:t}).find((function(t){return\"timezonename\"===t.type.toLowerCase()}));return n&&n.value};var s=f.startOf;f.startOf=function(t,e){if(!this.$x||!this.$x.$timezone)return s.call(this,t,e);var n=o(this.format(\"YYYY-MM-DD HH:mm:ss:SSS\"),{locale:this.$L});return s.call(n,t,e).tz(this.$x.$timezone,!0)},o.tz=function(t,e,n){var i=n&&e,a=n||e||r,f=u(+o(),a);if(\"string\"!=typeof t)return o(t).tz(a);var s=function(t,e,n){var i=t-60*e*1e3,o=u(i,n);if(e===o)return[i,e];var r=u(i-=60*(o-e)*1e3,n);return o===r?[i,o]:[t-60*Math.min(o,r)*1e3,Math.max(o,r)]}(o.utc(t,i).valueOf(),f,a),m=s[0],c=s[1],d=o(m).utcOffset(c);return d.$x.$timezone=a,d},o.tz.guess=function(){return Intl.DateTimeFormat().resolvedOptions().timeZone},o.tz.setDefault=function(t){r=t}}}));","!function(n,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(n=\"undefined\"!=typeof globalThis?globalThis:n||self).dayjs_plugin_localeData=e()}(this,(function(){\"use strict\";return function(n,e,t){var r=e.prototype,o=function(n){return n&&(n.indexOf?n:n.s)},u=function(n,e,t,r,u){var i=n.name?n:n.$locale(),a=o(i[e]),s=o(i[t]),f=a||s.map((function(n){return n.slice(0,r)}));if(!u)return f;var d=i.weekStart;return f.map((function(n,e){return f[(e+(d||0))%7]}))},i=function(){return t.Ls[t.locale()]},a=function(n,e){return n.formats[e]||function(n){return n.replace(/(\\[[^\\]]+])|(MMMM|MM|DD|dddd)/g,(function(n,e,t){return e||t.slice(1)}))}(n.formats[e.toUpperCase()])},s=function(){var n=this;return{months:function(e){return e?e.format(\"MMMM\"):u(n,\"months\")},monthsShort:function(e){return e?e.format(\"MMM\"):u(n,\"monthsShort\",\"months\",3)},firstDayOfWeek:function(){return n.$locale().weekStart||0},weekdays:function(e){return e?e.format(\"dddd\"):u(n,\"weekdays\")},weekdaysMin:function(e){return e?e.format(\"dd\"):u(n,\"weekdaysMin\",\"weekdays\",2)},weekdaysShort:function(e){return e?e.format(\"ddd\"):u(n,\"weekdaysShort\",\"weekdays\",3)},longDateFormat:function(e){return a(n.$locale(),e)},meridiem:this.$locale().meridiem,ordinal:this.$locale().ordinal}};r.localeData=function(){return s.bind(this)()},t.localeData=function(){var n=i();return{firstDayOfWeek:function(){return n.weekStart||0},weekdays:function(){return t.weekdays()},weekdaysShort:function(){return t.weekdaysShort()},weekdaysMin:function(){return t.weekdaysMin()},months:function(){return t.months()},monthsShort:function(){return t.monthsShort()},longDateFormat:function(e){return a(n,e)},meridiem:n.meridiem,ordinal:n.ordinal}},t.months=function(){return u(i(),\"months\")},t.monthsShort=function(){return u(i(),\"monthsShort\",\"months\",3)},t.weekdays=function(n){return u(i(),\"weekdays\",null,null,n)},t.weekdaysShort=function(n){return u(i(),\"weekdaysShort\",\"weekdays\",3,n)},t.weekdaysMin=function(n){return u(i(),\"weekdaysMin\",\"weekdays\",2,n)}}}));","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_localizedFormat=t()}(this,(function(){\"use strict\";var e={LTS:\"h:mm:ss A\",LT:\"h:mm A\",L:\"MM/DD/YYYY\",LL:\"MMMM D, YYYY\",LLL:\"MMMM D, YYYY h:mm A\",LLLL:\"dddd, MMMM D, YYYY h:mm A\"};return function(t,o,n){var r=o.prototype,i=r.format;n.en.formats=e,r.format=function(t){void 0===t&&(t=\"YYYY-MM-DDTHH:mm:ssZ\");var o=this.$locale().formats,n=function(t,o){return t.replace(/(\\[[^\\]]+])|(LTS?|l{1,4}|L{1,4})/g,(function(t,n,r){var i=r&&r.toUpperCase();return n||o[r]||e[r]||o[i].replace(/(\\[[^\\]]+])|(MMMM|MM|DD|dddd)/g,(function(e,t,o){return t||o.slice(1)}))}))}(t,void 0===o?{}:o);return i.call(this,n)}}}));","!function(e,n){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=n():\"function\"==typeof define&&define.amd?define(n):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_updateLocale=n()}(this,(function(){\"use strict\";return function(e,n,t){t.updateLocale=function(e,n){var o=t.Ls[e];if(o)return(n?Object.keys(n):[]).forEach((function(e){o[e]=n[e]})),o}}}));","import dayjs from 'dayjs';\nimport weekOfYear from 'dayjs/plugin/weekOfYear';\nimport dayOfYear from 'dayjs/plugin/dayOfYear';\nimport weekday from 'dayjs/plugin/weekday';\nimport minMax from 'dayjs/plugin/minMax';\nimport isoWeeksInYear from 'dayjs/plugin/isoWeeksInYear';\nimport isoWeek from 'dayjs/plugin/isoWeek';\nimport isLeapYear from 'dayjs/plugin/isLeapYear';\nimport advancedFormat from 'dayjs/plugin/advancedFormat';\nimport utc from 'dayjs/plugin/utc';\nimport timezone from 'dayjs/plugin/timezone';\nimport localeData from 'dayjs/plugin/localeData';\nimport localizedFormat from 'dayjs/plugin/localizedFormat';\nimport updateLocale from 'dayjs/plugin/updateLocale';\n\nimport type { ManipulateType, PluginFunc, Ls } from 'dayjs';\nimport type { OptionsType } from '../options/Options';\nimport type { Timestamp, DomainType } from '../index';\n\ndayjs.extend(weekOfYear);\ndayjs.extend(isoWeeksInYear);\ndayjs.extend(isoWeek);\ndayjs.extend(isLeapYear);\ndayjs.extend(dayOfYear);\ndayjs.extend(weekday);\ndayjs.extend(minMax);\ndayjs.extend(advancedFormat);\ndayjs.extend(utc);\ndayjs.extend(timezone);\ndayjs.extend(localeData);\ndayjs.extend(localizedFormat);\ndayjs.extend(updateLocale);\n\nconst DEFAULT_LOCALE = 'en';\n\nexport default class DateHelper {\n locale: OptionsType['date']['locale'];\n\n timezone: string;\n\n constructor() {\n this.locale = DEFAULT_LOCALE;\n this.timezone = dayjs.tz.guess();\n if (typeof window === 'object') {\n (window as any).dayjs ||= dayjs;\n }\n }\n\n async setup({ options }: { options: OptionsType }) {\n this.timezone = options.date.timezone || dayjs.tz.guess();\n const userLocale = options.date.locale;\n\n if (typeof userLocale === 'string' && userLocale !== DEFAULT_LOCALE) {\n let locale;\n if (typeof window === 'object') {\n locale =\n (window as any)[`dayjs_locale_${userLocale}`] ||\n (await this.loadBrowserLocale(userLocale));\n } else {\n locale = await this.loadNodeLocale(userLocale);\n }\n dayjs.locale(userLocale);\n this.locale = locale;\n }\n\n if (typeof userLocale === 'object') {\n if (userLocale.hasOwnProperty('name')) {\n dayjs.locale(userLocale.name, userLocale);\n this.locale = userLocale;\n } else {\n this.locale = dayjs.updateLocale(DEFAULT_LOCALE, userLocale);\n }\n }\n }\n\n // eslint-disable-next-line class-methods-use-this\n extend(dayjsPlugin: PluginFunc): dayjs.Dayjs {\n return dayjs.extend(dayjsPlugin);\n }\n\n /**\n * Return the week number, relative to its month\n *\n * @param {number|Date} d Date or timestamp in milliseconds\n * @returns {number} The week number, relative to the month [0-5]\n */\n getMonthWeekNumber(d: Timestamp | dayjs.Dayjs): number {\n const dayjsDate = this.date(d);\n const date = dayjsDate.startOf('day');\n const endOfWeek = dayjsDate.startOf('month').endOf('week');\n\n if (date <= endOfWeek) {\n return 1;\n }\n return Math.ceil(date.diff(endOfWeek, 'weeks', true)) + 1;\n }\n\n /**\n * Return the number of weeks in the given month\n *\n * As there is no fixed standard to specify which month a partial week should\n * belongs to, the ISO week date standard is used, where:\n * - the first week of the month should have at least 4 days\n *\n * @see https://en.wikipedia.org/wiki/ISO_week_date\n *\n * @param {Timestamp | dayjs.Dayjs} d Datejs object or timestamp\n * @return {number} The number of weeks\n */\n getWeeksCountInMonth(d: Timestamp | dayjs.Dayjs): number {\n const pivotDate = this.date(d);\n\n return (\n this.getLastWeekOfMonth(pivotDate).diff(\n this.getFirstWeekOfMonth(pivotDate),\n 'week',\n ) + 1\n );\n }\n\n /**\n * Return the start of the first week of the month\n *\n * @see getWeeksCountInMonth() about standard warning\n * @return {dayjs.Dayjs} A dayjs object representing the start of the\n * first week\n */\n getFirstWeekOfMonth(d: Timestamp | dayjs.Dayjs): dayjs.Dayjs {\n const startOfMonth = this.date(d).startOf('month');\n let startOfFirstWeek = startOfMonth.startOf('week');\n if (startOfMonth.weekday() > 4) {\n startOfFirstWeek = startOfFirstWeek.add(1, 'week');\n }\n\n return startOfFirstWeek;\n }\n\n /**\n * Return the end of the last week of the month\n *\n * @see getWeeksCountInMonth() about standard warning\n * @return {dayjs.Dayjs} A dayjs object representing the end of the last week\n */\n getLastWeekOfMonth(d: Timestamp | dayjs.Dayjs): dayjs.Dayjs {\n const endOfMonth = this.date(d).endOf('month');\n let endOfLastWeek = endOfMonth.endOf('week');\n if (endOfMonth.weekday() < 4) {\n endOfLastWeek = endOfLastWeek.subtract(1, 'week');\n }\n\n return endOfLastWeek;\n }\n\n date(d: Timestamp | Date | dayjs.Dayjs | string = new Date()): dayjs.Dayjs {\n if (dayjs.isDayjs(d)) {\n return d;\n }\n\n return dayjs(d)\n .tz(this.timezone)\n .utcOffset(0)\n .locale(this.locale as (typeof Ls)[0] | string);\n }\n\n format(\n timestamp: Timestamp,\n formatter: null | string | Function,\n ...args: any\n ): string | null {\n if (typeof formatter === 'function') {\n return formatter(timestamp, ...args);\n }\n\n if (typeof formatter === 'string') {\n return this.date(timestamp).format(formatter);\n }\n\n return null;\n }\n\n /**\n * Return an array of time interval\n *\n * @param {number|Date} date A random date included in the wanted interval\n * @param {number|Date} range Length of the wanted interval, or a stop date.\n * @param {boolean} range Whether the end date should be excluded\n * from the result\n * @returns {Array} Array of unix timestamp, in milliseconds\n */\n intervals(\n interval: DomainType,\n date: Timestamp | Date | dayjs.Dayjs,\n range: number | Date | dayjs.Dayjs,\n excludeEnd: boolean = true,\n ): Timestamp[] {\n let start = this.date(date);\n let end: dayjs.Dayjs;\n if (typeof range === 'number') {\n end = start.add(range, interval as ManipulateType);\n } else if (dayjs.isDayjs(range)) {\n end = range;\n } else {\n end = this.date(range);\n }\n\n start = start.startOf(interval as ManipulateType);\n\n end = end.startOf(interval as ManipulateType);\n let pivot = dayjs.min(start, end)!;\n end = dayjs.max(start, end)!;\n const result: Timestamp[] = [];\n\n if (!excludeEnd) {\n end = end.add(1, 'second');\n }\n\n do {\n result.push(+pivot);\n pivot = pivot.add(1, interval as ManipulateType);\n } while (pivot < end);\n\n return result;\n }\n\n // this function will work cross-browser for loading scripts asynchronously\n // eslint-disable-next-line class-methods-use-this\n loadBrowserLocale(userLocale: string): Promise {\n return new Promise((resolve, reject) => {\n const s = document.createElement('script');\n s.type = 'text/javascript';\n s.async = true;\n s.src = `https://cdn.jsdelivr.net/npm/dayjs@1/locale/${userLocale}.js`;\n s.onerror = (err) => {\n reject(err);\n };\n s.onload = () => {\n resolve((window as any)[`dayjs_locale_${userLocale}`]);\n };\n document.head.appendChild(s);\n });\n }\n\n // eslint-disable-next-line class-methods-use-this\n loadNodeLocale(userLocale: string): Promise {\n return import(`dayjs/locale/${userLocale}.js`);\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar notARegExp = require('../internals/not-a-regexp');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\nvar correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');\n\nvar stringIndexOf = uncurryThis(''.indexOf);\n\n// `String.prototype.includes` method\n// https://tc39.es/ecma262/#sec-string.prototype.includes\n$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, {\n includes: function includes(searchString /* , position = 0 */) {\n return !!~stringIndexOf(\n toString(requireObjectCoercible(this)),\n toString(notARegExp(searchString)),\n arguments.length > 1 ? arguments[1] : undefined\n );\n }\n});\n","import type TemplateCollection from '../TemplateCollection';\nimport type { DomainOptions, SubDomainOptions, DataOptions } from './Options';\nimport type { DomainType } from '../index';\n\nconst ALLOWED_DATA_TYPES = ['json', 'csv', 'tsv', 'txt'];\n\n/**\n * Ensure that critical options are valid\n *\n * @throw {Error} on critical invalid options\n * @return {boolean} Returns true when there is not critical errors\n */\nexport default function validate(\n templateCollection: TemplateCollection,\n {\n domain,\n subDomain,\n data,\n }: {\n domain: Partial;\n subDomain: Partial;\n data: Partial;\n },\n): boolean {\n const domainType = domain.type as DomainType;\n const subDomainType = subDomain.type as string;\n\n if (!templateCollection.has(domainType)) {\n throw new Error(`'${domainType}' is not a valid domain type'`);\n }\n\n if (!templateCollection.has(subDomainType)) {\n throw new Error(`'${subDomainType}' is not a valid subDomain type'`);\n }\n\n if (data.type && !ALLOWED_DATA_TYPES.includes(data.type)) {\n throw new Error(`The data type '${data.type}' is not valid data type`);\n }\n\n if (\n !(templateCollection.get(subDomainType).allowedDomainType || []).includes(\n domainType,\n )\n ) {\n throw new Error(\n `The subDomain.type '${subDomainType}' can not be used together ` +\n `with the domain type ${domainType}`,\n );\n }\n\n return true;\n}\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Set` constructor\n// https://tc39.es/ecma262/#sec-set-objects\ncollection('Set', function (init) {\n return function Set() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","import isEqual from 'lodash-es/isEqual';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport {\n PluginDefinition,\n PluginOptions,\n IPluginContructor,\n IPlugin,\n} from '../index';\n\ntype PluginSetting = {\n options?: PluginOptions;\n dirty: boolean;\n};\n\nfunction createPlugin(\n Creator: IPluginContructor,\n calendar: CalHeatmap,\n): IPlugin {\n return new Creator(calendar);\n}\n\nfunction extractPluginName(\n PluginClass: IPluginContructor,\n options?: PluginOptions,\n): string {\n return `${new PluginClass().name}${options?.key || ''}`;\n}\n\nexport default class PluginManager {\n calendar: CalHeatmap;\n\n settings: Map;\n\n plugins: Map;\n\n pendingPaint: Set;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.settings = new Map();\n this.plugins = new Map();\n this.pendingPaint = new Set();\n }\n\n add(plugins: PluginDefinition[]): void {\n plugins.forEach(([PluginClass, pluginOptions]) => {\n const name = extractPluginName(PluginClass, pluginOptions);\n\n const existingPlugin = this.plugins.get(name);\n\n if (\n existingPlugin &&\n this.settings.get(name) &&\n isEqual(this.settings.get(name)!.options, pluginOptions)\n ) {\n return;\n }\n\n this.settings.set(name, {\n options: pluginOptions,\n dirty: true,\n });\n\n if (!this.plugins.has(name)) {\n this.plugins.set(name, createPlugin(PluginClass, this.calendar));\n }\n\n this.pendingPaint.add(this.plugins.get(name)!);\n });\n }\n\n setupAll(): void {\n this.plugins.forEach((pluginInstance, name) => {\n const settings = this.settings.get(name);\n\n if (typeof settings !== 'undefined') {\n if (settings.dirty) {\n pluginInstance.setup(settings.options);\n settings.dirty = false;\n\n this.settings.set(name, settings);\n }\n }\n });\n }\n\n paintAll(): Promise[] {\n return Array.from(this.pendingPaint.values()).map((p) => p.paint());\n }\n\n destroyAll(): Promise[] {\n return this.allPlugins().map((p) => p.destroy());\n }\n\n getFromPosition(position: PluginOptions['position']): IPlugin[] {\n return this.allPlugins().filter(\n (plugin) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n plugin.options?.position === position,\n );\n }\n\n getHeightFromPosition(position: PluginOptions['position']): number {\n return this.getFromPosition(position)\n .map((d) => d.options.dimensions!.height)\n .reduce((a, b) => a + b, 0);\n }\n\n getWidthFromPosition(position: PluginOptions['position']): number {\n return this.getFromPosition(position)\n .map((d) => d.options.dimensions!.width)\n .reduce((a, b) => a + b, 0);\n }\n\n allPlugins(): IPlugin[] {\n return Array.from(this.plugins.values());\n }\n}\n","import minuteTemplate from './minute';\nimport hourTemplate from './hour';\nimport dayTemplate from './day';\nimport xDayTemplate from './xDay';\nimport ghDayTemplate from './ghDay';\nimport weekTemplate from './week';\nimport monthTemplate from './month';\nimport yearTemplate from './year';\n\nexport default [\n minuteTemplate,\n hourTemplate,\n dayTemplate,\n xDayTemplate,\n ghDayTemplate,\n weekTemplate,\n monthTemplate,\n yearTemplate,\n];\n","import type { Template, DomainType } from '../index';\n\nconst minuteTemplate: Template = (DateHelper) => {\n const COLUMNS_COUNT = 10;\n const ROWS_COUNT = 6;\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['day', 'hour'];\n\n return {\n name: 'minute',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => COLUMNS_COUNT,\n columnsCount: () => ROWS_COUNT,\n mapping: (startTimestamp, endTimestamp) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n DateHelper.intervals(\n 'minute',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts, index: number) => ({\n t: ts,\n x: Math.floor(index / COLUMNS_COUNT),\n y: index % COLUMNS_COUNT,\n })),\n extractUnit: (ts) => DateHelper.date(ts).startOf('minute').valueOf(),\n };\n};\n\nexport default minuteTemplate;\n","import type { DomainOptions } from '../options/Options';\nimport type { Template, DomainType } from '../index';\n\nconst hourTemplate: Template = (\n DateHelper,\n { domain }: { domain: DomainOptions },\n) => {\n const TOTAL_ITEMS = 24;\n const ROWS_COUNT = 6;\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['month', 'week', 'day'];\n\n return {\n name: 'hour',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => ROWS_COUNT,\n columnsCount: (ts) => {\n switch (domain.type) {\n case 'week':\n return (TOTAL_ITEMS / ROWS_COUNT) * 7;\n case 'month':\n return (\n (TOTAL_ITEMS / ROWS_COUNT) *\n (domain.dynamicDimension ? DateHelper.date(ts).daysInMonth() : 31)\n );\n case 'day':\n default:\n return TOTAL_ITEMS / ROWS_COUNT;\n }\n },\n mapping: (startTimestamp, endTimestamp) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n DateHelper.intervals(\n 'hour',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts) => {\n const date = DateHelper.date(ts);\n const hour = date.hour();\n const monthDate = date.date();\n let baseX = Math.floor(hour / ROWS_COUNT);\n const columnOffset = TOTAL_ITEMS / ROWS_COUNT;\n\n if (domain.type === 'month') {\n baseX += (monthDate - 1) * columnOffset;\n }\n if (domain.type === 'week') {\n baseX += +date.format('d') * columnOffset;\n }\n\n return {\n t: ts,\n x: baseX,\n y: Math.floor(hour % ROWS_COUNT),\n };\n }),\n extractUnit: (ts) => DateHelper.date(ts).startOf('hour').valueOf(),\n };\n};\n\nexport default hourTemplate;\n","import type { OptionsType, DomainOptions } from '../options/Options';\nimport type { Template, DomainType } from '../index';\n\nconst dayTemplate: Template = (\n DateHelper,\n {\n domain,\n verticalOrientation,\n }: {\n domain: DomainOptions;\n verticalOrientation: OptionsType['verticalOrientation'];\n },\n) => {\n const ROWS_COUNT = 7;\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['year', 'month', 'week'];\n\n return {\n name: 'day',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => (domain.type === 'week' ? 1 : ROWS_COUNT),\n columnsCount: (ts) => {\n switch (domain.type) {\n case 'month':\n return Math.ceil(\n domain.dynamicDimension && !verticalOrientation ?\n DateHelper.getMonthWeekNumber(\n DateHelper.date(ts).endOf('month'),\n ) :\n 6, // In rare case, when the first week contains less than 3 days\n );\n case 'year':\n return Math.ceil(\n domain.dynamicDimension ?\n DateHelper.date(ts).endOf('year').dayOfYear() / ROWS_COUNT :\n 54,\n );\n case 'week':\n default:\n return ROWS_COUNT;\n }\n },\n mapping: (startTimestamp, endTimestamp) => {\n let weekNumber = 0;\n let x = -1;\n\n return DateHelper.intervals(\n 'day',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts) => {\n const date = DateHelper.date(ts);\n\n switch (domain.type) {\n case 'month':\n x = DateHelper.getMonthWeekNumber(ts) - 1;\n break;\n case 'year':\n if (weekNumber !== date.week()) {\n weekNumber = date.week();\n x += 1;\n }\n break;\n case 'week':\n x = date.weekday();\n break;\n default:\n }\n\n return {\n t: ts,\n x,\n y: domain.type === 'week' ? 0 : date.weekday(),\n };\n });\n },\n extractUnit: (ts) => DateHelper.date(ts).startOf('day').valueOf(),\n };\n};\n\nexport default dayTemplate;\n","import type { OptionsType, DomainOptions } from '../options/Options';\nimport type { Template, DomainType } from '../index';\n\nconst dayTemplate: Template = (\n DateHelper,\n {\n domain,\n verticalOrientation,\n }: {\n domain: DomainOptions;\n verticalOrientation: OptionsType['verticalOrientation'];\n },\n) => {\n const COLUMNS_COUNT = 7;\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['year', 'month', 'week'];\n\n return {\n name: 'xDay',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: (ts) => {\n switch (domain.type) {\n case 'month':\n return Math.ceil(\n domain.dynamicDimension && !verticalOrientation ?\n DateHelper.getMonthWeekNumber(\n DateHelper.date(ts).endOf('month'),\n ) :\n 6, // In rare case, when the first week contains less than 3 days\n );\n case 'year':\n return Math.ceil(\n domain.dynamicDimension ?\n DateHelper.date(ts).endOf('year').dayOfYear() / COLUMNS_COUNT :\n 54,\n );\n case 'week':\n default:\n return COLUMNS_COUNT;\n }\n },\n columnsCount: () => {\n if (domain.type === 'week') {\n return 1;\n }\n return COLUMNS_COUNT;\n },\n mapping: (startTimestamp, endTimestamp) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n DateHelper.intervals(\n 'day',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts) => {\n const date = DateHelper.date(ts);\n const endWeekNumber = date.endOf('year').week();\n let x = 0;\n\n switch (domain.type) {\n case 'month':\n x = DateHelper.getMonthWeekNumber(ts) - 1;\n break;\n case 'year':\n if (endWeekNumber === 1 && date.week() === endWeekNumber) {\n x = date.subtract(1, 'week').week() + 1;\n }\n\n x = date.week() - 1;\n break;\n case 'week':\n x = date.weekday();\n break;\n default:\n }\n\n return {\n t: ts,\n y: x,\n x: domain.type === 'week' ? 0 : date.weekday(),\n };\n }),\n extractUnit: (ts) => DateHelper.date(ts).startOf('day').valueOf(),\n };\n};\n\nexport default dayTemplate;\n","import type { Template, DomainType } from '../index';\n\nconst dayTemplate: Template = (DateHelper) => {\n const ROWS_COUNT = 7;\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['month'];\n\n return {\n name: 'ghDay',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => ROWS_COUNT,\n columnsCount: (ts) => DateHelper.getWeeksCountInMonth(ts),\n mapping: (startTimestamp, endTimestamp) => {\n const clampStart = DateHelper.getFirstWeekOfMonth(startTimestamp);\n const clampEnd = DateHelper.getFirstWeekOfMonth(endTimestamp);\n\n let x = -1;\n const pivotDay = clampStart.weekday();\n\n return DateHelper.intervals('day', clampStart, clampEnd).map((ts) => {\n const weekday = DateHelper.date(ts).weekday();\n if (weekday === pivotDay) {\n x += 1;\n }\n\n return {\n t: ts,\n x,\n y: weekday,\n };\n });\n },\n extractUnit: (ts) => DateHelper.date(ts).startOf('day').valueOf(),\n };\n};\n\nexport default dayTemplate;\n","import type { DomainOptions } from '../options/Options';\nimport type { Template, DomainType } from '../index';\n\nconst weekTemplate: Template = (\n DateHelper,\n { domain }: { domain: DomainOptions },\n) => {\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['year', 'month'];\n\n return {\n name: 'week',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => 1,\n columnsCount: (ts) => {\n switch (domain.type) {\n case 'year':\n return domain.dynamicDimension ?\n DateHelper.date(ts).endOf('year').isoWeeksInYear() :\n 53;\n case 'month':\n return domain.dynamicDimension ?\n DateHelper.getWeeksCountInMonth(ts) :\n 5;\n default:\n return 1;\n }\n },\n mapping: (startTimestamp, endTimestamp) => {\n const clampStart = DateHelper.getFirstWeekOfMonth(startTimestamp);\n const clampEnd = DateHelper.getFirstWeekOfMonth(endTimestamp);\n\n return DateHelper.intervals('week', clampStart, clampEnd).map(\n (ts, i) => ({\n t: ts,\n x: i,\n y: 0,\n }),\n );\n },\n extractUnit: (ts) => DateHelper.date(ts).startOf('week').valueOf(),\n };\n};\n\nexport default weekTemplate;\n","import type { Template, DomainType } from '../index';\n\nconst monthTemplate: Template = (DateHelper) => {\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['year'];\n\n return {\n name: 'month',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => 1,\n columnsCount: () => 12,\n mapping: (startTimestamp, endTimestamp) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n DateHelper.intervals(\n 'month',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts) => ({\n t: ts,\n x: DateHelper.date(ts).month(),\n y: 0,\n })),\n extractUnit: (ts) => DateHelper.date(ts).startOf('month').valueOf(),\n };\n};\n\nexport default monthTemplate;\n","import type { Template, DomainType } from '../index';\n\nconst yearTemplate: Template = (DateHelper) => {\n const ALLOWED_DOMAIN_TYPE: DomainType[] = [];\n\n return {\n name: 'year',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => 1,\n columnsCount: () => 1,\n mapping: (startTimestamp, endTimestamp) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n DateHelper.intervals(\n 'year',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts, index) => ({\n t: ts,\n x: index,\n y: 0,\n })),\n extractUnit: (ts) => DateHelper.date(ts).startOf('year').valueOf(),\n };\n};\n\nexport default yearTemplate;\n","import castArray from 'lodash-es/castArray';\n\nimport DefaultTemplates from './templates/index';\nimport type Options from './options/Options';\nimport type { Template, TemplateResult } from './index';\nimport type DateHelper from './helpers/DateHelper';\n\nexport default class TemplateCollection {\n dateHelper: DateHelper;\n\n options: Options;\n\n settings: Map;\n\n // Whether the default templates has been initiated\n initiated: boolean;\n\n constructor(dateHelper: DateHelper, options: Options) {\n this.settings = new Map();\n this.dateHelper = dateHelper;\n this.options = options;\n this.initiated = false;\n }\n\n get(subDomainType: string): TemplateResult {\n return this.settings.get(subDomainType)!;\n }\n\n has(subDomainType: string): boolean {\n return this.settings.has(subDomainType);\n }\n\n init() {\n if (!this.initiated) {\n this.initiated = true;\n this.add(DefaultTemplates);\n }\n }\n\n add(templates: Template | Template[]) {\n this.init();\n\n const tplWithParent: string[] = [];\n castArray(templates).forEach((f) => {\n const template = f(this.dateHelper, this.options.options);\n this.settings.set(template.name, template);\n\n if (template.hasOwnProperty('parent')) {\n tplWithParent.push(template.name);\n }\n });\n\n tplWithParent.forEach((name) => {\n const parentTemplate = this.settings.get(\n this.settings.get(name)!.parent!,\n );\n\n if (!parentTemplate) {\n return;\n }\n\n this.settings.set(name, {\n ...parentTemplate,\n ...this.settings.get(name),\n });\n });\n }\n}\n","import EventEmmiter from 'eventemitter3';\nimport castArray from 'lodash-es/castArray';\nimport type { PluginFunc } from 'dayjs';\nimport type dayjs from 'dayjs';\n\nimport Navigator from './calendar/Navigator';\nimport CalendarPainter from './calendar/CalendarPainter';\nimport Populator from './calendar/Populator';\nimport Options from './options/Options';\nimport DataFetcher from './DataFetcher';\nimport DomainCollection from './calendar/DomainCollection';\nimport DateHelper from './helpers/DateHelper';\nimport validate from './options/OptionsValidator';\nimport PluginManager from './plugins/PluginManager';\nimport VERSION from './version';\n\nimport './cal-heatmap.scss';\n\nimport TemplateCollection from './TemplateCollection';\n\nimport type { OptionsType } from './options/Options';\nimport type {\n Template,\n Dimensions,\n PluginDefinition,\n Timestamp,\n} from './index';\n\nimport { ScrollDirection } from './constant';\n\nexport default class CalHeatmap {\n static VERSION = VERSION;\n\n options: Options;\n\n calendarPainter: CalendarPainter;\n\n populator: Populator;\n\n navigator: Navigator;\n\n eventEmitter: EventEmmiter;\n\n dataFetcher: DataFetcher;\n\n domainCollection!: DomainCollection;\n\n templateCollection: TemplateCollection;\n\n dateHelper: DateHelper;\n\n pluginManager: PluginManager;\n\n constructor() {\n // Default options\n this.options = new Options();\n\n // Init the helpers with the default options\n this.dateHelper = new DateHelper();\n this.templateCollection = new TemplateCollection(\n this.dateHelper,\n this.options,\n );\n this.dataFetcher = new DataFetcher(this);\n this.navigator = new Navigator(this);\n this.populator = new Populator(this);\n\n this.calendarPainter = new CalendarPainter(this);\n this.eventEmitter = new EventEmmiter();\n this.pluginManager = new PluginManager(this);\n }\n\n createDomainCollection(\n startDate: Timestamp | Date,\n range: number | Date,\n excludeEnd: boolean = true,\n ): DomainCollection {\n return new DomainCollection(\n this.dateHelper,\n this.options.options.domain.type,\n startDate,\n range,\n excludeEnd,\n );\n }\n\n // =========================================================================\n // PUBLIC API\n // =========================================================================\n\n /**\n * Setup and paint the calendar with the given options\n *\n * @param {Object} options The Options object\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n async paint(\n options?: CalHeatmap.DeepPartial,\n plugins?: PluginDefinition[] | PluginDefinition,\n ): Promise {\n this.options.init(options);\n await this.dateHelper.setup(this.options);\n\n this.templateCollection.init();\n\n try {\n validate(this.templateCollection, this.options.options);\n } catch (error) {\n return Promise.reject(error);\n }\n\n if (plugins) {\n this.pluginManager.add(castArray(plugins as any) as PluginDefinition[]);\n }\n\n this.calendarPainter.setup();\n\n // Record all the valid domains\n // Each domain value is a timestamp in milliseconds\n this.domainCollection = new DomainCollection(this.dateHelper);\n this.navigator.loadNewDomains(\n this.createDomainCollection(\n this.options.options.date.start,\n this.options.options.range,\n ),\n );\n\n return Promise.allSettled([this.calendarPainter.paint(), this.fill()]);\n }\n\n /**\n * Add a new subDomainTemplate\n *\n * @since 4.0.0\n * @param {SubDomainTemplate[] | SubDomainTemplate} templates\n * A single, or an array of SubDomainTemplate object\n * @return void\n */\n addTemplates(templates: Template | Template[]): void {\n this.templateCollection.add(templates);\n }\n\n /**\n * Shift the calendar by n domains forward\n *\n * @param {number} n Number of domain intervals to shift forward\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n next(n: number = 1): Promise {\n const loadDirection = this.navigator.loadNewDomains(\n this.createDomainCollection(this.domainCollection.max, n + 1).slice(n),\n ScrollDirection.SCROLL_FORWARD,\n );\n\n return Promise.allSettled([\n this.calendarPainter.paint(loadDirection),\n this.fill(),\n ]);\n }\n\n /**\n * Shift the calendar by n domains backward\n *\n * @param {number} n Number of domain intervals to shift backward\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n previous(n: number = 1): Promise {\n const loadDirection = this.navigator.loadNewDomains(\n this.createDomainCollection(this.domainCollection.min, -n),\n ScrollDirection.SCROLL_BACKWARD,\n );\n\n return Promise.allSettled([\n this.calendarPainter.paint(loadDirection),\n this.fill(),\n ]);\n }\n\n /**\n * Jump directly to a specific date\n *\n * JumpTo will scroll the calendar until the wanted domain with the specified\n * date is visible. Unless you set reset to true, the wanted domain\n * will not necessarily be the first domain of the calendar.\n *\n * @param {Date} date Jump to the domain containing that date\n * @param {boolean} reset Whether the wanted domain\n * should be the first domain of the calendar\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n jumpTo(date: Date, reset: boolean = false): Promise {\n return Promise.allSettled([\n this.calendarPainter.paint(this.navigator.jumpTo(date, reset)),\n this.fill(),\n ]);\n }\n\n /**\n * Fill the calendar with the given data\n *\n * @param {Object|string} dataSource The calendar's datasource,\n * same type as `options.data.source`\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n fill(dataSource = this.options.options.data.source): Promise {\n const { options } = this.options;\n const template = this.templateCollection;\n const endDate = this.dateHelper.intervals(\n options.domain.type,\n this.domainCollection.max,\n 2,\n )[1];\n\n const dataPromise = this.dataFetcher.getDatas(\n dataSource,\n this.domainCollection.min,\n endDate,\n );\n\n return new Promise((resolve, reject) => {\n dataPromise.then(\n (data: any) => {\n this.domainCollection.fill(\n data,\n options.data,\n template.get(options.subDomain.type)!.extractUnit,\n );\n this.populator.populate();\n resolve(null);\n },\n (error) => {\n reject(error);\n },\n );\n });\n }\n\n /**\n * Listener for all events\n *\n * @since 4.0.0\n * @param {string} eventName Name of the event to listen to\n * @param {function} Callback function to execute on event trigger\n * @return void\n */\n on(name: string, fn: (...args: any[]) => any): void {\n this.eventEmitter.on(name, fn);\n }\n\n dimensions(): Dimensions {\n return this.calendarPainter.dimensions;\n }\n\n /**\n * Destroy the calendar\n *\n * @since 3.3.6\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n destroy(): Promise {\n return this.calendarPainter.destroy();\n }\n\n extendDayjs(plugin: PluginFunc): dayjs.Dayjs {\n return this.dateHelper.extend(plugin);\n }\n}\n","const VERSION = '4.2.4';\nexport default VERSION;\n"],"names":["check","it","Math","global","globalThis","window","self","this","Function","shared$4","exports","require$$0","defineProperty","Object","defineGlobalProperty","key","value","configurable","writable","error","require$$1","SHARED","sharedStore","store","sharedModule","undefined","push","version","mode","copyright","license","source","match","fails","exec","functionBindNative","test","bind","hasOwnProperty","NATIVE_BIND","FunctionPrototype","prototype","call","uncurryThisWithBind","functionUncurryThis","fn","apply","arguments","isNullOrUndefined","$TypeError","TypeError","requireObjectCoercible","$Object","toObject","argument","hasOwnProperty_1","hasOwn","uncurryThis","id","postfix","random","toString","uid","engineUserAgent","navigator","String","userAgent","process","Deno","versions","v8","split","engineV8Version","V8_VERSION","$String","require$$2","symbolConstructorDetection","getOwnPropertySymbols","symbol","Symbol","sham","useSymbolAsUid","iterator","shared","require$$3","NATIVE_SYMBOL","require$$4","USE_SYMBOL_AS_UID","require$$5","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","wellKnownSymbol","name","toStringTagSupport","documentAll","document","all","documentAll_1","IS_HTMLDDA","isCallable","objectDefineProperty","descriptors","get","isObject","EXISTS","createElement","documentCreateElement","ie8DomDefine","a","v8PrototypeDefineBug","anObject","functionCall","getBuiltIn","namespace","method","length","objectIsPrototypeOf","isPrototypeOf","isSymbol","$Symbol","tryToString","aCallable","getMethod","V","P","func","ordinaryToPrimitive","input","pref","val","valueOf","TO_PRIMITIVE","toPrimitive","result","exoticToPrim","toPropertyKey","DESCRIPTORS","IE8_DOM_DEFINE","V8_PROTOTYPE_DEFINE_BUG","$defineProperty","$getOwnPropertyDescriptor","getOwnPropertyDescriptor","ENUMERABLE","CONFIGURABLE","WRITABLE","f","O","Attributes","current","enumerable","makeBuiltIn$3","getDescriptor","functionName","PROPER","functionToString","inspectSource","set","has","WeakMap","weakMapBasicDetection","createPropertyDescriptor","bitmap","definePropertyModule","createNonEnumerableProperty","object","keys","sharedKey","hiddenKeys","NATIVE_WEAK_MAP","require$$6","require$$7","OBJECT_ALREADY_INITIALIZED","state","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","CONFIGURABLE_FUNCTION_NAME","enforceInternalState","getInternalState","stringSlice","slice","replace","join","CONFIGURABLE_LENGTH","TEMPLATE","makeBuiltIn","makeBuiltInModule","options","getter","setter","arity","constructor","defineBuiltIn","simple","unsafe","nonConfigurable","nonWritable","classofRaw","TO_STRING_TAG_SUPPORT","TO_STRING_TAG","CORRECT_ARGUMENTS","classof","tag","tryGet","callee","objectGetOwnPropertyDescriptor","objectPropertyIsEnumerable","$propertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","descriptor","indexedObject","IndexedObject","toIndexedObject","propertyIsEnumerableModule","objectGetOwnPropertyNames","ceil","floor","trunc","x","n","toIntegerOrInfinity","number","max","min","toAbsoluteIndex","index","integer","toLength","lengthOfArrayLike","obj","createMethod","IS_INCLUDES","$this","el","fromIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","i","enumBugKeys","internalObjectKeys","concat","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","ownKeys","getOwnPropertyDescriptorModule","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","toLowerCase","isForced_1","copyConstructorProperties","target","exceptions","_export","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","engineIsNode","uncurryThisAccessor","aPossiblePrototype","objectSetPrototypeOf","setPrototypeOf","CORRECT_SETTER","Array","proto","__proto__","setToStringTag","TAG","defineBuiltInAccessor","SPECIES","setSpecies","CONSTRUCTOR_NAME","Constructor","anInstance","Prototype","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","$location","defer","channel","port","isConstructor","called","aConstructor","functionApply","Reflect","functionUncurryThisClause","functionBindContext","that","html","arraySlice","engineIsIos","require$$8","validateArgumentsLength","passed","required","IS_IOS","require$$10","IS_NODE","require$$11","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","location","run","runner","eventListener","event","globalPostMessageDefer","postMessage","protocol","host","handler","args","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","task","Queue","head","tail","add","item","entry","next","notify","toggle","node","promise","then","engineIsIosPebble","Pebble","engineIsWebosWebkit","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","Promise","queueMicrotaskDescriptor","microtask","flush","parent","domain","exit","enter","resolve","createTextNode","observe","characterData","microtask_1","perform","promiseNativeConstructor","engineIsDeno","engineIsBrowser","NativePromiseConstructor","IS_BROWSER","IS_DENO","require$$9","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","promiseConstructorDetection","CONSTRUCTOR","REJECTION_EVENT","newPromiseCapability$2","PromiseCapability","C","reject","$$resolve","$$reject","newPromiseCapability","Internal","OwnPromiseCapability","nativeThen","$","require$$12","speciesConstructor","defaultConstructor","S","require$$14","require$$15","hostReportErrors","b","console","require$$17","require$$18","InternalStateModule","require$$19","require$$20","newPromiseCapabilityModule","require$$22","PROMISE","require$$21","NATIVE_PROMISE_SUBCLASSING","getInternalPromiseState","setInternalState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","isThenable","callReaction","reaction","exited","ok","fail","rejection","onHandleUnhandled","isReject","notified","reactions","onUnhandled","reason","initEvent","isUnhandled","emit","unwrap","internalReject","done","internalResolve","wrapper","executor","onFulfilled","onRejected","PromiseWrapper","wrap","iterators","Iterators","ITERATOR","ArrayPrototype","isArrayIteratorMethod","getIteratorMethod","getIterator","usingIterator","iteratorMethod","iteratorClose","kind","innerResult","innerError","Result","stopped","ResultPrototype","iterate","iterable","unboundFunction","iterFn","step","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","SAFE_CLOSING","iteratorWithReturn","return","from","checkCorrectnessOfIteration","SKIP_CLOSING","ITERATION_SUPPORT","promiseStaticsIncorrectIteration","capability","$promiseResolve","values","remaining","alreadyCalled","real","catch","race","r","promiseResolve","promiseCapability","objectDefineProperties","objectKeys","defineProperties","Properties","props","activeXDocument","definePropertiesModule","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","style","display","src","contentWindow","open","F","objectCreate","create","UNSCOPABLES","IteratorPrototype","PrototypeOfArrayIteratorPrototype","arrayIterator","addToUnscopables","correctPrototypeGetter","getPrototypeOf","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","objectGetPrototypeOf","BUGGY_SAFARI_ITERATORS","NEW_ITERATOR_PROTOTYPE","iteratorsCore","returnThis","createIteratorConstructor","IteratorConstructor","NAME","ENUMERABLE_NEXT","PROPER_FUNCTION_NAME","require$$13","KEYS","VALUES","ENTRIES","iteratorDefine","Iterable","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","createIterResultObject","defineIterator","ARRAY_ITERATOR","es_array_iterator","iterated","Arguments","allSettled","status","charAt","charCodeAt","CONVERT_TO_STRING","pos","first","second","position","size","stringMultibyte","codeAt","STRING_ITERATOR","point","domIterables","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DOMTokenList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","classList","DOMTokenListPrototype","domTokenListPrototype","DOMIterables","ArrayIteratorMethods","ArrayValues","handlePrototype","CollectionPrototype","COLLECTION_NAME","METHOD_NAME","fill","argumentsLength","end","endPos","isArray","createProperty","propertyKey","arrayMethodHasSpeciesSupport","array","foo","Boolean","nativeSlice","HAS_SPECIES_SUPPORT","$Array","__awaiter","thisArg","_arguments","generator","fulfilled","e","rejected","__classPrivateFieldGet","receiver","start","k","fin","prefix","Events","EE","context","once","addListener","emitter","listener","evt","_events","_eventsCount","clearEvent","EventEmitter","eventNames","events","listeners","handlers","l","ee","listenerCount","a1","a2","a3","a4","a5","len","removeListener","j","on","removeAllListeners","off","prefixed","module","isArray$3","castArray","arraySpeciesConstructor","originalArray","arraySpeciesCreate","IS_MAP","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_REJECT","NO_HOLES","callbackfn","specificCreate","boundFunction","arrayIteration","forEach","map","filter","some","every","find","findIndex","filterReject","$map","$assign","assign","objectAssign","A","B","alphabet","chr","T","internalMetadata","objectGetOwnPropertyNamesExternal","arraySliceSimple","$getOwnPropertyNames","windowNames","getWindowNames","arrayBufferNonExtensible","ArrayBuffer","buffer","isExtensible","ARRAY_BUFFER_NON_EXTENSIBLE","$isExtensible","objectIsExtensible","freezing","preventExtensions","getOwnPropertyNamesExternalModule","FREEZING","REQUIRED","METADATA","setMetadata","objectID","weakData","meta","internalMetadataModule","enable","splice","fastKey","getWeakData","onFreeze","InternalMetadataModule","inheritIfRequired","dummy","Wrapper","NewTarget","NewTargetPrototype","collection","common","IS_WEAK","ADDER","NativeConstructor","NativePrototype","exported","fixMethod","uncurriedNativeMethod","getConstructor","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","setStrong","defineBuiltIns","internalStateGetterFor","uncaughtFrozenStore","frozen","UncaughtFrozenStore","findUncaughtFrozen","delete","ScrollDirection","Position","collectionWeak","define","init","SCALE_BASE_OPACITY_COLOR","SCALE_BASE_COLOR_DOMAIN","Navigator","calendar","_classCallCheck","maxDomainReached","minDomainReached","_createClass","newDomainCollection","_this","direction","SCROLL_NONE","templatesClt","templateCollection","minDate","date","extractUnit","maxDate","domainCollection","_Navigator_instances","_Navigator_isDomainBoundaryReached","clamp","range","SCROLL_FORWARD","merge","domainKey","subDomainEndDate","at","dateHelper","intervals","pop","subDomain","mapping","d","v","defaultValue","_Navigator_setDomainsBoundaryReached","SCROLL_BACKWARD","eventEmitter","reset","_this$calendar","Date","loadNewDomains","createDomainCollection","WeakSet","lowerBound","upperBound","reached","doesNotExceedSafeInteger","IS_CONCAT_SPREADABLE","IS_CONCAT_SPREADABLE_SUPPORT","isConcatSpreadable","spreadable","arg","E","arrayMethodIsStrict","nativeJoin","separator","collectionStrong","last","previous","getEntry","removed","prev","ITERATOR_NAME","getInternalCollectionState","getInternalIteratorState","mergeSort","comparefn","middle","insertionSort","element","left","right","llength","rlength","lindex","rindex","arraySort","firefox","engineFfVersion","engineIsIeOrEdge","webkit","engineWebkitVersion","deletePropertyOrThrow","internalSort","FF","IE_OR_EDGE","V8","WEBKIT","nativeSort","sort","FAILS_ON_UNDEFINED","FAILS_ON_NULL","STRICT_METHOD","STABLE_SORT","code","fromCharCode","itemsLength","items","arrayLength","y","getSortCompare","$forEach","isVertical","horizontalPadding","padding","LEFT","RIGHT","verticalPadding","TOP","BOTTOM","DomainCoordinates","domainPainter","Map","scrollDirection","_this$calendar$option","verticalOrientation","dimensions","width","height","exitingTotal","scrollFactor","reverse","yankedDomains","coor","w","_DomainCoordinates_instances","_DomainCoordinates_getWidth","h","_DomainCoordinates_getHeight","pre_x","pre_y","inner_width","gutter","inner_height","_this$calendar$option2","columnsCount","subDomainWidth","domainHorizontalLabelWidth","_this$calendar$option3","rowsCount","subDomainHeight","domainVerticalLabelHeight","DEFAULT_SELECTOR","DomainPainter","coordinates","root","rootNode","animationDuration","t","transition","duration","update","promises","selectAll","append","attr","enterSelection","updateSelection","exitSelection","remove","classname","helper","hour","format","week","month","year","$includes","$filter","callWithSafeIterationClosing","arrayLike","IS_CONSTRUCTOR","mapfn","DOMAIN_FORMAT","xDay","ghDay","day","minute","DomainCollection","interval","excludeEnd","ts","_DomainCollection_instances","_DomainCollection_refreshKeys","callback","newCollection","limit","createValueCallback","_this2","keyToRemove","_this3","fromBeginning","_ref","subDomainKeyExtractor","_this4","groupY","groupedRecords","groupRecords","records","_DomainCollection_setSubDomainValues","_this5","results","validSubDomainTimestamp","timestamp","extractTimestamp","groupFn","cleanedValues","reduce","_toConsumableArray","datum","extractorFn","_this6","groupValues","_DomainCollection_extractValues","parseInt","DomainLabelPainter","label","text","textAlign","_DomainLabelPainter_instances","_DomainLabelPainter_textVerticalAlign","nodes","selection","_DomainLabelPainter_domainRotate","rotate","_this$calendar$option4","offset","_DomainLabelPainter_getDomainInsideWidth","_this$calendar$option5","_this$calendar$option6","_this$calendar$option7","_DomainLabelPainter_getDomainInsideHeight","_this$calendar$option8","calendarPainter","domainsContainerPainter","_this$calendar$option9","_this$calendar$option10","_this$calendar$option11","labelWidth","domainWidth","domainHeight","s","whitespaces","ltrim","RegExp","rtrim","stringTrim","trim","$trim","forcedStringTrimMethod","SubDomainPainter","containerClassname","subDomainSvgGroup","_SubDomainPainter_instances","_SubDomainPainter_setPositions","radius","subDomainsCollection","abs","insert","_SubDomainPainter_classname","ev","_SubDomainPainter_appendText","_options$domain","highlight","unitFn","_len","otherClasses","_key","elem","_SubDomainPainter_getCoordinates","axis","BASE_SELECTOR","TRANSITION_CLASSNAME","DomainsContainerPainter","subDomainPainter","domainLabelPainter","transitionsQueueCount","_DomainsContainerPainter_instances","_DomainsContainerPainter_startAnimation","paint","_DomainsContainerPainter_recomputeDimensions","_DomainsContainerPainter_endAnimation","_a","topHeight","pluginManager","getHeightFromPosition","leftWidth","getWidthFromPosition","select","parentNode","classed","domainsDimensions","PluginPainter","paintAll","setPluginsPosition","top","getFromPosition","bottom","topOffset","plugin","leftOffset","CalendarPainter","pluginPainter","itemSelector","theme","setup","setupAll","navigationDir","transitions","updatePosition","_CalendarPainter_instances","_CalendarPainter_resize","destroyAll","destroy","insideHeight","_CalendarPainter_getWidth","insideWidth","newWidth","newHeight","freeGlobal$1","freeSelf","root$1","freeGlobal","Symbol$2","objectProto","nativeObjectToString","symToStringTag","toStringTag","nullTag","undefinedTag","baseGetTag","isOwn","unmasked","getRawTag","objectToString","asyncTag","funcTag","genTag","proxyTag","isFunction","nativeKeys","MATCH","isRegExp","notARegexp","correctIsRegexpLogic","regexp","error1","error2","notARegExp","correctIsRegExpLogic","nativeStartsWith","startsWith","CORRECT_IS_REGEXP_LOGIC","searchString","search","IE_BUG","TO_ENTRIES","IE_WORKAROUND","$entries","defined","Number","isNaN","ascendingDefined","ascending","finite","isFinite","NaN","positive","negative","re","parse","fallback","timeIntervals","timeSecond","timeMinute","timeHour","timeDay","timeWeek","timeMonth","timeYear","timeMonday","timeTuesday","timeWednesday","timeThursday","timeFriday","timeSaturday","timeSunday","utcIntervals","utcSecond","utcMinute","utcHour","utcDay","utcWeek","utcMonth","utcYear","utcMonday","utcTuesday","utcWednesday","utcThursday","utcFriday","utcSaturday","utcSunday","maybeTimeInterval","Error","maybeUtcInterval","TypedArray","Uint8Array","constant","coerceNumbers","coerceNumber","Float64Array","coerceDates","coerceDate","isoParse","arrayify","isScaleOptions","option","maybeInterval","isInteger","lo","hi","rangei","maybeRangeInterval","isOrdinal","isTemporal","isTemporalString","isNumericString","orderof","descending","color","opacity","registry","sqrt4_3","sqrt","symbols","symbolAsterisk","symbolCircle","symbolCross","symbolDiamond","symbolDiamond2","draw","rx","PI","ry","hy","moveTo","lineTo","closePath","symbolPlus","symbolSquare","symbolSquare2","symbolStar","symbolTimes","symbolTriangle","symbolTriangle2","symbolWye","maybeSymbol","isSymbolObject","warn","message","ordinalSchemes","schemeAccent","schemeCategory10","schemeDark2","schemePaired","schemePastel1","schemePastel2","schemeSet1","schemeSet2","schemeSet3","schemeTableau10","scheme11","schemeBrBG","interpolateBrBG","schemePRGn","interpolatePRGn","schemePiYG","interpolatePiYG","schemePuOr","interpolatePuOr","schemeRdBu","interpolateRdBu","schemeRdGy","interpolateRdGy","schemeRdYlBu","interpolateRdYlBu","schemeRdYlGn","interpolateRdYlGn","schemeSpectral","interpolateSpectral","scheme11r","scheme9","schemeBlues","interpolateBlues","schemeGreens","interpolateGreens","schemeGreys","interpolateGreys","schemeOranges","interpolateOranges","schemePurples","interpolatePurples","schemeReds","interpolateReds","schemei","interpolateTurbo","interpolateViridis","interpolateMagma","interpolateInferno","interpolatePlasma","interpolateCividis","interpolateCubehelixDefault","interpolateWarm","interpolateCool","schemeBuGn","interpolateBuGn","schemeBuPu","interpolateBuPu","schemeGnBu","interpolateGnBu","schemeOrRd","interpolateOrRd","schemePuBu","interpolatePuBu","schemePuBuGn","interpolatePuBuGn","schemePuRd","interpolatePuRd","schemeRdPu","interpolateRdPu","schemeYlGn","interpolateYlGn","schemeYlGnBu","interpolateYlGnBu","schemeYlOrBr","interpolateYlOrBr","schemeYlOrRd","interpolateYlOrRd","schemeicyclical","interpolateRainbow","interpolateSinebow","scheme","interpolate","quantize","ordinalScheme","ordinalRange","quantitativeSchemes","quantitativeScheme","divergingSchemes","Set","isDivergingScheme","flip","unit","interpolators","interpolateNumber","interpolateRgb","interpolateHsl","interpolateHcl","interpolateLab","maybeInterpolator","createScaleQ","scale","channels","nice","zero","inferAutoDomain","unknown","round","inferRadialRange","inferLengthRange","interpolateRound","_","interpolatePiecewise","extent","sign","reverseof","maybeNiceInterval","maybeNice","createScalePow","exponent","scalePow","createScaleThreshold","isOrdered","scaleThreshold","inferDomain","inferZeroDomain","hint","h25","quantile","h50","median","inferLogDomain","inferQuantileDomain","createScaleD","transform","pivot","symmetric","piecewise","mid","mindelta","maxdelta","invert","interpolator","createScaleDivergingPow","scaleDivergingPow","transformSqrt","pow","transformPow","createScaleDivergingSymlog","scaleDivergingSymlog","log1p","expm1","transformSymlog","transformIdentity","transformLog","log","exp","createScaleT","ordinalImplicit","createScaleO","createScaleOrdinal","inferHint","stroke","inferSymbolHint","isNone","symbolsStroke","symbolsFill","inferSymbolRange","maybeBooleanRange","t0","scaleImplicit","scaleOrdinal","maybeRound","InternSet","candidate","normalizeScale","projection","typeProjection","asOrdinalType","inferScaleType","isOrdinalScale","formatScaleType","coerceType","coerceSymbols","scaleDiverging","createScaleDiverging","createScaleDivergingSqrt","base","scaleDivergingLog","createScaleDivergingLog","scaleLinear","createScaleLinear","createScaleSqrt","quantiles","scaleQuantile","createScaleQuantile","thresholds","ticks","createScaleQuantize","scaleLog","createScaleLog","scaleSymlog","createScaleSymlog","scaleUtc","createScaleUtc","scaleTime","createScaleTime","align","scalePoint","createScalePoint","paddingInner","paddingOuter","scaleBand","createScaleBand","scaleIdentity","createScale","description","coerceValues","c","exposeScale","percent","bandwidth","normalizedScale","scaleOptions","scaleType","applyScaleStyle","_scale","keyname","styles","baseColor","scaleStyle","_ref2","_slicedToArray","prop","Populator","_calendar$options$opt","colorScale","defaultColor","hcl","eq","other","assocIndexOf","ListCache","__data__","coreJsData$1","maskSrcKey","coreJsData","funcToString","toSource","reIsHostCtor","funcProto","reIsNative","baseIsNative","getNative","getValue","Map$2","nativeCreate$1","Hash","getMapData","MapCache","nativeCreate","hash","Stack","pairs","LARGE_ARRAY_SIZE","defineProperty$1","baseAssignValue","assignMergeValue","fromRight","baseFor","iteratee","keysFunc","baseFor$1","freeExports","nodeType","freeModule","Buffer","allocUnsafe","Uint8Array$2","cloneTypedArray","typedArray","isDeep","arrayBuffer","byteLength","byteOffset","baseCreate$1","overArg","getPrototype$1","isPrototype","Ctor","isObjectLike","baseIsArguments","isArguments$1","MAX_SAFE_INTEGER","isLength","isArrayLike","isBuffer$1","isBuffer","objectTag","objectCtorString","typedArrayTags","freeProcess","nodeUtil","types","require","binding","nodeIsTypedArray","isTypedArray","isTypedArray$1","safeGet","assignValue","objValue","reIsUint","isIndex","arrayLikeKeys","inherited","isArr","isArg","isArguments","isBuff","isType","skipIndexes","baseTimes","baseKeysIn","nativeKeysIn","isProto","keysIn","toPlainObject","customizer","isNew","newValue","copyObject","baseMergeDeep","srcIndex","mergeFunc","stack","srcValue","stacked","isCommon","isTyped","copyArray","copy","cloneBuffer","getPrototype","isPlainObject","baseCreate","initCloneObject","baseMerge","identity","nativeMax","baseSetToString","baseSetToString$1","nativeNow","setToString","count","lastCalled","stamp","shortOut","setToString$1","baseRest","otherArgs","overRest","assigner","mergeWith","sources","guard","isIterateeCall","mergeWith$1","SetCache","arraySome","predicate","COMPARE_PARTIAL_FLAG","COMPARE_UNORDERED_FLAG","equalArrays","bitmask","equalFunc","isPartial","arrLength","othLength","arrStacked","othStacked","seen","arrValue","othValue","compared","othIndex","mapToArray","setToArray","boolTag","dateTag","errorTag","mapTag","numberTag","regexpTag","setTag","stringTag","symbolTag","arrayBufferTag","dataViewTag","symbolProto","symbolValueOf","nativeGetSymbols","getSymbols","resIndex","arrayFilter","getSymbols$1","nativeKeys$1","baseKeys","getAllKeys","symbolsFunc","arrayPush","baseGetAllKeys","DataView$1","Promise$2","Set$2","WeakMap$1","promiseTag","weakMapTag","dataViewCtorString","DataView","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","getTag","ctorString","getTag$1","argsTag","arrayTag","baseIsEqualDeep","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","convert","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","objLength","objStacked","skipCtor","objCtor","othCtor","equalObjects","baseIsEqual","isEqual","baseHas","reIsDeepProp","reIsPlainProp","FUNC_ERROR_TEXT","memoize","resolver","memoized","cache","Cache","rePropName","reEscapeChar","stringToPath","memoizeCapped","quote","subString","stringToPath$1","INFINITY","symbolToString","baseToString","arrayMap","castPath","isKey","toKey","path","hasFunc","hasPath","baseGet","lastIndex","nested","baseSet","re1","re2","OptionsPreProcessors","isString","Options","processors","preProcessors","dynamicDimension","locale","timezone","requestInit","opts","initScale","$RegExp","UNSUPPORTED_Y","MISSED_STICKY","sticky","BROKEN_CARET","regexpStickyHelpers","regexpUnsupportedDotAll","dotAll","flags","regexpUnsupportedNcg","groups","regexpFlags","hasIndices","ignoreCase","multiline","unicode","unicodeSets","stickyHelpers","UNSUPPORTED_DOT_ALL","UNSUPPORTED_NCG","nativeReplace","nativeExec","patchedExec","UPDATES_LAST_INDEX_WRONG","NPCG_INCLUDED","reCopy","group","str","raw","charsAdded","strCopy","regexpExec","RegExpPrototype","SUBSTITUTION_SYMBOLS","SUBSTITUTION_SYMBOLS_NO_NAMED","fixRegExpWellKnownSymbolLogic","SHAM","SYMBOL","DELEGATES_TO_SYMBOL","DELEGATES_TO_EXEC","execCalled","uncurriedNativeRegExpMethod","nativeMethod","arg2","forceStringMethod","$exec","advanceStringIndex","getSubstitution","matched","captures","namedCaptures","tailPos","m","ch","capture","regExpExec","R","REPLACE","require$$16","stringIndexOf","REPLACE_KEEPS_$0","REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE","REPLACE_SUPPORTS_NAMED_GROUPS","maybeCallNative","UNSAFE_SUBSTITUTE","searchValue","replaceValue","replacer","res","functionalReplace","fullUnicode","accumulatedResult","nextSourcePosition","replacerArgs","DataFetcher","startTimestamp","endTimestamp","_context","abrupt","_DataFetcher_instances","_DataFetcher_fetch","_callee","newUri","url","parseURI","json","csv","dsv","FUNCTION_NAME_EXISTS","nameRE","dayjs_min","u","o","M","weekdays","months","ordinal","z","utcOffset","clone","p","D","ms","Q","g","$L","utc","$u","$x","$offset","$d","substring","UTC","$y","getFullYear","$M","getMonth","$D","getDate","$W","getDay","$H","getHours","$m","getMinutes","$s","getSeconds","$ms","getMilliseconds","$utils","isValid","isSame","startOf","endOf","isAfter","isBefore","$g","unix","getTime","toDate","$locale","weekStart","$set","daysInMonth","subtract","invalidDate","meridiem","monthsShort","weekdaysMin","weekdaysShort","getTimezoneOffset","diff","toJSON","toISOString","toUTCString","extend","$i","isDayjs","en","Ls","yearStart","weeks","dayOfYear","weekday","isoWeeksInYear","isLeapYear","isoWeekday","isoWeekYear","isoWeek","weekYear","offsetName","local","getUTCFullYear","getUTCMonth","getUTCDate","getUTCDay","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","$localOffset","isUTC","timeZoneName","Intl","DateTimeFormat","hour12","timeZone","formatToParts","tz","toLocaleString","$timezone","guess","resolvedOptions","setDefault","formats","toUpperCase","firstDayOfWeek","longDateFormat","localeData","LTS","L","LL","LLL","LLLL","updateLocale","dayjs","weekOfYear","minMax","advancedFormat","localizedFormat","DEFAULT_LOCALE","DateHelper","_typeof","userLocale","loadBrowserLocale","sent","loadNodeLocale","dayjsPlugin","dayjsDate","endOfWeek","pivotDate","getLastWeekOfMonth","getFirstWeekOfMonth","startOfMonth","startOfFirstWeek","endOfMonth","endOfLastWeek","formatter","async","onerror","err","onload","import","ALLOWED_DATA_TYPES","validate","domainType","subDomainType","allowedDomainType","PluginManager","settings","plugins","pendingPaint","Creator","PluginClass","pluginOptions","extractPluginName","dirty","pluginInstance","allPlugins","TOTAL_ITEMS","monthDate","baseX","getMonthWeekNumber","weekNumber","endWeekNumber","getWeeksCountInMonth","clampStart","clampEnd","pivotDay","TemplateCollection","initiated","DefaultTemplates","templates","tplWithParent","template","parentTemplate","CalHeatmap","dataFetcher","populator","EventEmmiter","startDate","loadDirection","jumpTo","dataSource","endDate","dataPromise","getDatas","populate","VERSION"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,159,161,162,163,164,165,166,167,168,169,170,171,172,173,174,178,179,180,181,182,185,186,187,188,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,355,356,358,359,360,361,362,363,364,365,366,367,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,385,387]} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.js b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.js new file mode 100644 index 0000000..962447d --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.js @@ -0,0 +1 @@ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e(require("d3-selection"),require("d3-color"),require("d3"),require("d3-fetch")):"function"==typeof define&&define.amd?define(["d3-selection","d3-color","d3","d3-fetch"],e):(t="undefined"!=typeof globalThis?globalThis:t||self).CalHeatmap=e(t.d3,t.d3,t.d3,t.d3)}(this,(function(t,e,n,r){"use strict";function i(){i=function(){return t};var t={},e=Object.prototype,n=e.hasOwnProperty,r=Object.defineProperty||function(t,e,n){t[e]=n.value},o="function"==typeof Symbol?Symbol:{},a=o.iterator||"@@iterator",u=o.asyncIterator||"@@asyncIterator",s=o.toStringTag||"@@toStringTag";function c(t,e,n){return Object.defineProperty(t,e,{value:n,enumerable:!0,configurable:!0,writable:!0}),t[e]}try{c({},"")}catch(t){c=function(t,e,n){return t[e]=n}}function l(t,e,n,i){var o=e&&e.prototype instanceof d?e:d,a=Object.create(o.prototype),u=new _(i||[]);return r(a,"_invoke",{value:O(t,n,u)}),a}function f(t,e,n){try{return{type:"normal",arg:t.call(e,n)}}catch(t){return{type:"throw",arg:t}}}t.wrap=l;var h={};function d(){}function p(){}function v(){}var y={};c(y,a,(function(){return this}));var m=Object.getPrototypeOf,g=m&&m(m(M([])));g&&g!==e&&n.call(g,a)&&(y=g);var b=v.prototype=d.prototype=Object.create(y);function w(t){["next","throw","return"].forEach((function(e){c(t,e,(function(t){return this._invoke(e,t)}))}))}function x(t,e){function i(r,o,a,u){var s=f(t[r],t,o);if("throw"!==s.type){var c=s.arg,l=c.value;return l&&"object"==typeof l&&n.call(l,"__await")?e.resolve(l.__await).then((function(t){i("next",t,a,u)}),(function(t){i("throw",t,a,u)})):e.resolve(l).then((function(t){c.value=t,a(c)}),(function(t){return i("throw",t,a,u)}))}u(s.arg)}var o;r(this,"_invoke",{value:function(t,n){function r(){return new e((function(e,r){i(t,n,e,r)}))}return o=o?o.then(r,r):r()}})}function O(t,e,n){var r="suspendedStart";return function(i,o){if("executing"===r)throw new Error("Generator is already running");if("completed"===r){if("throw"===i)throw o;return D()}for(n.method=i,n.arg=o;;){var a=n.delegate;if(a){var u=k(a,n);if(u){if(u===h)continue;return u}}if("next"===n.method)n.sent=n._sent=n.arg;else if("throw"===n.method){if("suspendedStart"===r)throw r="completed",n.arg;n.dispatchException(n.arg)}else"return"===n.method&&n.abrupt("return",n.arg);r="executing";var s=f(t,e,n);if("normal"===s.type){if(r=n.done?"completed":"suspendedYield",s.arg===h)continue;return{value:s.arg,done:n.done}}"throw"===s.type&&(r="completed",n.method="throw",n.arg=s.arg)}}}function k(t,e){var n=e.method,r=t.iterator[n];if(void 0===r)return e.delegate=null,"throw"===n&&t.iterator.return&&(e.method="return",e.arg=void 0,k(t,e),"throw"===e.method)||"return"!==n&&(e.method="throw",e.arg=new TypeError("The iterator does not provide a '"+n+"' method")),h;var i=f(r,t.iterator,e.arg);if("throw"===i.type)return e.method="throw",e.arg=i.arg,e.delegate=null,h;var o=i.arg;return o?o.done?(e[t.resultName]=o.value,e.next=t.nextLoc,"return"!==e.method&&(e.method="next",e.arg=void 0),e.delegate=null,h):o:(e.method="throw",e.arg=new TypeError("iterator result is not an object"),e.delegate=null,h)}function S(t){var e={tryLoc:t[0]};1 in t&&(e.catchLoc=t[1]),2 in t&&(e.finallyLoc=t[2],e.afterLoc=t[3]),this.tryEntries.push(e)}function j(t){var e=t.completion||{};e.type="normal",delete e.arg,t.completion=e}function _(t){this.tryEntries=[{tryLoc:"root"}],t.forEach(S,this),this.reset(!0)}function M(t){if(t){var e=t[a];if(e)return e.call(t);if("function"==typeof t.next)return t;if(!isNaN(t.length)){var r=-1,i=function e(){for(;++r=0;--i){var o=this.tryEntries[i],a=o.completion;if("root"===o.tryLoc)return r("end");if(o.tryLoc<=this.prev){var u=n.call(o,"catchLoc"),s=n.call(o,"finallyLoc");if(u&&s){if(this.prev=0;--r){var i=this.tryEntries[r];if(i.tryLoc<=this.prev&&n.call(i,"finallyLoc")&&this.prev=0;--e){var n=this.tryEntries[e];if(n.finallyLoc===t)return this.complete(n.completion,n.afterLoc),j(n),h}},catch:function(t){for(var e=this.tryEntries.length-1;e>=0;--e){var n=this.tryEntries[e];if(n.tryLoc===t){var r=n.completion;if("throw"===r.type){var i=r.arg;j(n)}return i}}throw new Error("illegal catch attempt")},delegateYield:function(t,e,n){return this.delegate={iterator:M(t),resultName:e,nextLoc:n},"next"===this.method&&(this.arg=void 0),h}},t}function o(t){return o="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},o(t)}function a(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function u(t,e){for(var n=0;nt.length)&&(e=t.length);for(var n=0,r=new Array(e);n0&&_[0]<4?1:+(_[0]+_[1])),!M&&X&&(!(_=X.match(/Edge\/(\d+)/))||_[1]>=74)&&(_=X.match(/Chrome\/(\d+)/))&&(M=+_[1]);var it=M,ot=it,at=P,ut=m.String,st=!!Object.getOwnPropertySymbols&&!at((function(){var t=Symbol("symbol detection");return!ut(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&ot&&ot<41})),ct=st&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,lt=D,ft=G,ht=Z,dt=st,pt=ct,vt=m.Symbol,yt=lt("wks"),mt=pt?vt.for||vt:vt&&vt.withoutSetter||ht,gt=function(t){return ft(yt,t)||(yt[t]=dt&&ft(vt,t)?vt[t]:mt("Symbol."+t)),yt[t]},bt={};bt[gt("toStringTag")]="z";var wt="[object z]"===String(bt),xt="object"==typeof document&&document.all,Ot={all:xt,IS_HTMLDDA:void 0===xt&&void 0!==xt},kt=Ot.all,St=Ot.IS_HTMLDDA?function(t){return"function"==typeof t||t===kt}:function(t){return"function"==typeof t},jt={},_t=!P((function(){return 7!==Object.defineProperty({},1,{get:function(){return 7}})[1]})),Mt=St,Dt=Ot.all,Pt=Ot.IS_HTMLDDA?function(t){return"object"==typeof t?null!==t:Mt(t)||t===Dt}:function(t){return"object"==typeof t?null!==t:Mt(t)},$t=Pt,Et=m.document,Lt=$t(Et)&&$t(Et.createElement),Tt=function(t){return Lt?Et.createElement(t):{}},Ct=Tt,At=!_t&&!P((function(){return 7!==Object.defineProperty(Ct("div"),"a",{get:function(){return 7}}).a})),Rt=_t&&P((function(){return 42!==Object.defineProperty((function(){}),"prototype",{value:42,writable:!1}).prototype})),It=Pt,Nt=String,Wt=TypeError,Yt=function(t){if(It(t))return t;throw new Wt(Nt(t)+" is not an object")},zt=$,Ft=Function.prototype.call,Ht=zt?Ft.bind(Ft):function(){return Ft.apply(Ft,arguments)},Bt=m,Gt=St,Ut=function(t,e){return arguments.length<2?(n=Bt[t],Gt(n)?n:void 0):Bt[t]&&Bt[t][e];var n},qt=A({}.isPrototypeOf),Vt=Ut,Kt=St,Zt=qt,Qt=Object,Jt=ct?function(t){return"symbol"==typeof t}:function(t){var e=Vt("Symbol");return Kt(e)&&Zt(e.prototype,Qt(t))},Xt=String,te=function(t){try{return Xt(t)}catch(t){return"Object"}},ee=St,ne=te,re=TypeError,ie=function(t){if(ee(t))return t;throw new re(ne(t)+" is not a function")},oe=ie,ae=R,ue=function(t,e){var n=t[e];return ae(n)?void 0:oe(n)},se=Ht,ce=St,le=Pt,fe=TypeError,he=Ht,de=Pt,pe=Jt,ve=ue,ye=function(t,e){var n,r;if("string"===e&&ce(n=t.toString)&&!le(r=se(n,t)))return r;if(ce(n=t.valueOf)&&!le(r=se(n,t)))return r;if("string"!==e&&ce(n=t.toString)&&!le(r=se(n,t)))return r;throw new fe("Can't convert object to primitive value")},me=TypeError,ge=gt("toPrimitive"),be=function(t,e){if(!de(t)||pe(t))return t;var n,r=ve(t,ge);if(r){if(void 0===e&&(e="default"),n=he(r,t,e),!de(n)||pe(n))return n;throw new me("Can't convert object to primitive value")}return void 0===e&&(e="number"),ye(t,e)},we=Jt,xe=function(t){var e=be(t,"string");return we(e)?e:e+""},Oe=_t,ke=At,Se=Rt,je=Yt,_e=xe,Me=TypeError,De=Object.defineProperty,Pe=Object.getOwnPropertyDescriptor,$e="enumerable",Ee="configurable",Le="writable";jt.f=Oe?Se?function(t,e,n){if(je(t),e=_e(e),je(n),"function"==typeof t&&"prototype"===e&&"value"in n&&Le in n&&!n[Le]){var r=Pe(t,e);r&&r[Le]&&(t[e]=n.value,n={configurable:Ee in n?n[Ee]:r[Ee],enumerable:$e in n?n[$e]:r[$e],writable:!1})}return De(t,e,n)}:De:function(t,e,n){if(je(t),e=_e(e),je(n),ke)try{return De(t,e,n)}catch(t){}if("get"in n||"set"in n)throw new Me("Accessors not supported");return"value"in n&&(t[e]=n.value),t};var Te={exports:{}},Ce=_t,Ae=G,Re=Function.prototype,Ie=Ce&&Object.getOwnPropertyDescriptor,Ne=Ae(Re,"name"),We={EXISTS:Ne,PROPER:Ne&&"something"===function(){}.name,CONFIGURABLE:Ne&&(!Ce||Ce&&Ie(Re,"name").configurable)},Ye=St,ze=S,Fe=A(Function.toString);Ye(ze.inspectSource)||(ze.inspectSource=function(t){return Fe(t)});var He,Be,Ge,Ue=ze.inspectSource,qe=St,Ve=m.WeakMap,Ke=qe(Ve)&&/native code/.test(String(Ve)),Ze=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}},Qe=jt,Je=Ze,Xe=_t?function(t,e,n){return Qe.f(t,e,Je(1,n))}:function(t,e,n){return t[e]=n,t},tn=Z,en=D("keys"),nn=function(t){return en[t]||(en[t]=tn(t))},rn={},on=Ke,an=m,un=Pt,sn=Xe,cn=G,ln=S,fn=nn,hn=rn,dn="Object already initialized",pn=an.TypeError,vn=an.WeakMap;if(on||ln.state){var yn=ln.state||(ln.state=new vn);yn.get=yn.get,yn.has=yn.has,yn.set=yn.set,He=function(t,e){if(yn.has(t))throw new pn(dn);return e.facade=t,yn.set(t,e),e},Be=function(t){return yn.get(t)||{}},Ge=function(t){return yn.has(t)}}else{var mn=fn("state");hn[mn]=!0,He=function(t,e){if(cn(t,mn))throw new pn(dn);return e.facade=t,sn(t,mn,e),e},Be=function(t){return cn(t,mn)?t[mn]:{}},Ge=function(t){return cn(t,mn)}}var gn={set:He,get:Be,has:Ge,enforce:function(t){return Ge(t)?Be(t):He(t,{})},getterFor:function(t){return function(e){var n;if(!un(e)||(n=Be(e)).type!==t)throw new pn("Incompatible receiver, "+t+" required");return n}}},bn=A,wn=P,xn=St,On=G,kn=_t,Sn=We.CONFIGURABLE,jn=Ue,_n=gn.enforce,Mn=gn.get,Dn=String,Pn=Object.defineProperty,$n=bn("".slice),En=bn("".replace),Ln=bn([].join),Tn=kn&&!wn((function(){return 8!==Pn((function(){}),"length",{value:8}).length})),Cn=String(String).split("String"),An=Te.exports=function(t,e,n){"Symbol("===$n(Dn(e),0,7)&&(e="["+En(Dn(e),/^Symbol\(([^)]*)\)/,"$1")+"]"),n&&n.getter&&(e="get "+e),n&&n.setter&&(e="set "+e),(!On(t,"name")||Sn&&t.name!==e)&&(kn?Pn(t,"name",{value:e,configurable:!0}):t.name=e),Tn&&n&&On(n,"arity")&&t.length!==n.arity&&Pn(t,"length",{value:n.arity});try{n&&On(n,"constructor")&&n.constructor?kn&&Pn(t,"prototype",{writable:!1}):t.prototype&&(t.prototype=void 0)}catch(t){}var r=_n(t);return On(r,"source")||(r.source=Ln(Cn,"string"==typeof e?e:"")),t};Function.prototype.toString=An((function(){return xn(this)&&Mn(this).source||jn(this)}),"toString");var Rn=Te.exports,In=St,Nn=jt,Wn=Rn,Yn=x,zn=function(t,e,n,r){r||(r={});var i=r.enumerable,o=void 0!==r.name?r.name:e;if(In(n)&&Wn(n,o,r),r.global)i?t[e]=n:Yn(e,n);else{try{r.unsafe?t[e]&&(i=!0):delete t[e]}catch(t){}i?t[e]=n:Nn.f(t,e,{value:n,enumerable:!1,configurable:!r.nonConfigurable,writable:!r.nonWritable})}return t},Fn=A,Hn=Fn({}.toString),Bn=Fn("".slice),Gn=function(t){return Bn(Hn(t),8,-1)},Un=wt,qn=St,Vn=Gn,Kn=gt("toStringTag"),Zn=Object,Qn="Arguments"===Vn(function(){return arguments}()),Jn=Un?Vn:function(t){var e,n,r;return void 0===t?"Undefined":null===t?"Null":"string"==typeof(n=function(t,e){try{return t[e]}catch(t){}}(e=Zn(t),Kn))?n:Qn?Vn(e):"Object"===(r=Vn(e))&&qn(e.callee)?"Arguments":r},Xn=Jn,tr=wt?{}.toString:function(){return"[object "+Xn(this)+"]"};wt||zn(Object.prototype,"toString",tr,{unsafe:!0});var er={},nr={},rr={}.propertyIsEnumerable,ir=Object.getOwnPropertyDescriptor,or=ir&&!rr.call({1:2},1);nr.f=or?function(t){var e=ir(this,t);return!!e&&e.enumerable}:rr;var ar=P,ur=Gn,sr=Object,cr=A("".split),lr=ar((function(){return!sr("z").propertyIsEnumerable(0)}))?function(t){return"String"===ur(t)?cr(t,""):sr(t)}:sr,fr=lr,hr=W,dr=function(t){return fr(hr(t))},pr=_t,vr=Ht,yr=nr,mr=Ze,gr=dr,br=xe,wr=G,xr=At,Or=Object.getOwnPropertyDescriptor;er.f=pr?Or:function(t,e){if(t=gr(t),e=br(e),xr)try{return Or(t,e)}catch(t){}if(wr(t,e))return mr(!vr(yr.f,t,e),t[e])};var kr={},Sr=Math.ceil,jr=Math.floor,_r=Math.trunc||function(t){var e=+t;return(e>0?jr:Sr)(e)},Mr=function(t){var e=+t;return e!=e||0===e?0:_r(e)},Dr=Mr,Pr=Math.max,$r=Math.min,Er=function(t,e){var n=Dr(t);return n<0?Pr(n+e,0):$r(n,e)},Lr=Mr,Tr=Math.min,Cr=function(t){return t>0?Tr(Lr(t),9007199254740991):0},Ar=Cr,Rr=function(t){return Ar(t.length)},Ir=dr,Nr=Er,Wr=Rr,Yr=function(t){return function(e,n,r){var i,o=Ir(e),a=Wr(o),u=Nr(r,a);if(t&&n!=n){for(;a>u;)if((i=o[u++])!=i)return!0}else for(;a>u;u++)if((t||u in o)&&o[u]===n)return t||u||0;return!t&&-1}},zr={includes:Yr(!0),indexOf:Yr(!1)},Fr=G,Hr=dr,Br=zr.indexOf,Gr=rn,Ur=A([].push),qr=function(t,e){var n,r=Hr(t),i=0,o=[];for(n in r)!Fr(Gr,n)&&Fr(r,n)&&Ur(o,n);for(;e.length>i;)Fr(r,n=e[i++])&&(~Br(o,n)||Ur(o,n));return o},Vr=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],Kr=qr,Zr=Vr.concat("length","prototype");kr.f=Object.getOwnPropertyNames||function(t){return Kr(t,Zr)};var Qr={};Qr.f=Object.getOwnPropertySymbols;var Jr=Ut,Xr=kr,ti=Qr,ei=Yt,ni=A([].concat),ri=Jr("Reflect","ownKeys")||function(t){var e=Xr.f(ei(t)),n=ti.f;return n?ni(e,n(t)):e},ii=G,oi=ri,ai=er,ui=jt,si=P,ci=St,li=/#|\.prototype\./,fi=function(t,e){var n=di[hi(t)];return n===vi||n!==pi&&(ci(e)?si(e):!!e)},hi=fi.normalize=function(t){return String(t).replace(li,".").toLowerCase()},di=fi.data={},pi=fi.NATIVE="N",vi=fi.POLYFILL="P",yi=fi,mi=m,gi=er.f,bi=Xe,wi=zn,xi=x,Oi=function(t,e,n){for(var r=oi(e),i=ui.f,o=ai.f,a=0;ao;o++)if((u=m(t[o]))&&$s(Rs,u))return u;return new As(!1)}r=Es(t,i)}for(s=h?t.next:r.next;!(c=js(s,r)).done;){try{u=m(c.value)}catch(t){Ts(r,"throw",t)}if("object"==typeof u&&u&&$s(Rs,u))return u}return new As(!1)},Ns=gt("iterator"),Ws=!1;try{var Ys=0,zs={next:function(){return{done:!!Ys++}},return:function(){Ws=!0}};zs[Ns]=function(){return this},Array.from(zs,(function(){throw 2}))}catch(t){}var Fs=function(t,e){try{if(!e&&!Ws)return!1}catch(t){return!1}var n=!1;try{var r={};r[Ns]=function(){return{next:function(){return{done:n=!0}}}},t(r)}catch(t){}return n},Hs=Wa,Bs=eu.CONSTRUCTOR||!Fs((function(t){Hs.all(t).then(void 0,(function(){}))})),Gs=Ht,Us=ie,qs=nu,Vs=Na,Ks=Is;Si({target:"Promise",stat:!0,forced:Bs},{all:function(t){var e=this,n=qs.f(e),r=n.resolve,i=n.reject,o=Vs((function(){var n=Us(e.resolve),o=[],a=0,u=1;Ks(t,(function(t){var s=a++,c=!1;u++,Gs(n,e,t).then((function(t){c||(c=!0,o[s]=t,--u||r(o))}),i)})),--u||r(o)}));return o.error&&i(o.value),n.promise}});var Zs=Si,Qs=eu.CONSTRUCTOR,Js=Wa,Xs=Ut,tc=St,ec=zn,nc=Js&&Js.prototype;if(Zs({target:"Promise",proto:!0,forced:Qs,real:!0},{catch:function(t){return this.then(void 0,t)}}),tc(Js)){var rc=Xs("Promise").prototype.catch;nc.catch!==rc&&ec(nc,"catch",rc,{unsafe:!0})}var ic=Ht,oc=ie,ac=nu,uc=Na,sc=Is;Si({target:"Promise",stat:!0,forced:Bs},{race:function(t){var e=this,n=ac.f(e),r=n.reject,i=uc((function(){var i=oc(e.resolve);sc(t,(function(t){ic(i,e,t).then(n.resolve,r)}))}));return i.error&&r(i.value),n.promise}});var cc=Ht,lc=nu;Si({target:"Promise",stat:!0,forced:eu.CONSTRUCTOR},{reject:function(t){var e=lc.f(this);return cc(e.reject,void 0,t),e.promise}});var fc=Yt,hc=Pt,dc=nu,pc=Si,vc=eu.CONSTRUCTOR,yc=function(t,e){if(fc(t),hc(e)&&e.constructor===t)return e;var n=dc.f(t);return(0,n.resolve)(e),n.promise};Ut("Promise"),pc({target:"Promise",stat:!0,forced:vc},{resolve:function(t){return yc(this,t)}});var mc={},gc=qr,bc=Vr,wc=Object.keys||function(t){return gc(t,bc)},xc=_t,Oc=Rt,kc=jt,Sc=Yt,jc=dr,_c=wc;mc.f=xc&&!Oc?Object.defineProperties:function(t,e){Sc(t);for(var n,r=jc(e),i=_c(e),o=i.length,a=0;o>a;)kc.f(t,n=i[a++],r[n]);return t};var Mc,Dc=Yt,Pc=mc,$c=Vr,Ec=rn,Lc=Co,Tc=Tt,Cc="prototype",Ac="script",Rc=nn("IE_PROTO"),Ic=function(){},Nc=function(t){return"<"+Ac+">"+t+""},Wc=function(t){t.write(Nc("")),t.close();var e=t.parentWindow.Object;return t=null,e},Yc=function(){try{Mc=new ActiveXObject("htmlfile")}catch(t){}var t,e,n;Yc="undefined"!=typeof document?document.domain&&Mc?Wc(Mc):(e=Tc("iframe"),n="java"+Ac+":",e.style.display="none",Lc.appendChild(e),e.src=String(n),(t=e.contentWindow.document).open(),t.write(Nc("document.F=Object")),t.close(),t.F):Wc(Mc);for(var r=$c.length;r--;)delete Yc[Cc][$c[r]];return Yc()};Ec[Rc]=!0;var zc=Object.create||function(t,e){var n;return null!==t?(Ic[Cc]=Dc(t),n=new Ic,Ic[Cc]=null,n[Rc]=t):n=Yc(),void 0===e?n:Pc.f(n,e)},Fc=gt,Hc=zc,Bc=jt.f,Gc=Fc("unscopables"),Uc=Array.prototype;void 0===Uc[Gc]&&Bc(Uc,Gc,{configurable:!0,value:Hc(null)});var qc,Vc,Kc,Zc=function(t){Uc[Gc][t]=!0},Qc=!P((function(){function t(){}return t.prototype.constructor=null,Object.getPrototypeOf(new t)!==t.prototype})),Jc=G,Xc=St,tl=F,el=Qc,nl=nn("IE_PROTO"),rl=Object,il=rl.prototype,ol=el?rl.getPrototypeOf:function(t){var e=tl(t);if(Jc(e,nl))return e[nl];var n=e.constructor;return Xc(n)&&e instanceof n?n.prototype:e instanceof rl?il:null},al=P,ul=St,sl=Pt,cl=ol,ll=zn,fl=gt("iterator"),hl=!1;[].keys&&("next"in(Kc=[].keys())?(Vc=cl(cl(Kc)))!==Object.prototype&&(qc=Vc):hl=!0);var dl=!sl(qc)||al((function(){var t={};return qc[fl].call(t)!==t}));dl&&(qc={}),ul(qc[fl])||ll(qc,fl,(function(){return this}));var pl={IteratorPrototype:qc,BUGGY_SAFARI_ITERATORS:hl},vl=pl.IteratorPrototype,yl=zc,ml=Ze,gl=Ni,bl=ns,wl=function(){return this},xl=Si,Ol=Ht,kl=St,Sl=function(t,e,n,r){var i=e+" Iterator";return t.prototype=yl(vl,{next:ml(+!r,n)}),gl(t,i,!1),bl[i]=wl,t},jl=ol,_l=Ci,Ml=Ni,Dl=Xe,Pl=zn,$l=ns,El=We.PROPER,Ll=We.CONFIGURABLE,Tl=pl.IteratorPrototype,Cl=pl.BUGGY_SAFARI_ITERATORS,Al=gt("iterator"),Rl="keys",Il="values",Nl="entries",Wl=function(){return this},Yl=function(t,e,n,r,i,o,a){Sl(n,e,r);var u,s,c,l=function(t){if(t===i&&v)return v;if(!Cl&&t&&t in d)return d[t];switch(t){case Rl:case Il:case Nl:return function(){return new n(this,t)}}return function(){return new n(this)}},f=e+" Iterator",h=!1,d=t.prototype,p=d[Al]||d["@@iterator"]||i&&d[i],v=!Cl&&p||l(i),y="Array"===e&&d.entries||p;if(y&&(u=jl(y.call(new t)))!==Object.prototype&&u.next&&(jl(u)!==Tl&&(_l?_l(u,Tl):kl(u[Al])||Pl(u,Al,Wl)),Ml(u,f,!0)),El&&i===Il&&p&&p.name!==Il&&(Ll?Dl(d,"name",Il):(h=!0,v=function(){return Ol(p,this)})),i)if(s={values:l(Il),keys:o?v:l(Rl),entries:l(Nl)},a)for(c in s)(Cl||h||!(c in d))&&Pl(d,c,s[c]);else xl({target:e,proto:!0,forced:Cl||h},s);return d[Al]!==v&&Pl(d,Al,v,{name:i}),$l[e]=v,s},zl=function(t,e){return{value:t,done:e}},Fl=dr,Hl=Zc,Bl=ns,Gl=gn,Ul=jt.f,ql=Yl,Vl=zl,Kl=_t,Zl="Array Iterator",Ql=Gl.set,Jl=Gl.getterFor(Zl),Xl=ql(Array,"Array",(function(t,e){Ql(this,{type:Zl,target:Fl(t),index:0,kind:e})}),(function(){var t=Jl(this),e=t.target,n=t.index++;if(!e||n>=e.length)return t.target=void 0,Vl(void 0,!0);switch(t.kind){case"keys":return Vl(n,!1);case"values":return Vl(e[n],!1)}return Vl([n,e[n]],!1)}),"values"),tf=Bl.Arguments=Bl.Array;if(Hl("keys"),Hl("values"),Hl("entries"),Kl&&"values"!==tf.name)try{Ul(tf,"name",{value:"values"})}catch(t){}var ef=Ht,nf=ie,rf=nu,of=Na,af=Is;Si({target:"Promise",stat:!0,forced:Bs},{allSettled:function(t){var e=this,n=rf.f(e),r=n.resolve,i=n.reject,o=of((function(){var n=nf(e.resolve),i=[],o=0,a=1;af(t,(function(t){var u=o++,s=!1;a++,ef(n,e,t).then((function(t){s||(s=!0,i[u]={status:"fulfilled",value:t},--a||r(i))}),(function(t){s||(s=!0,i[u]={status:"rejected",reason:t},--a||r(i))}))})),--a||r(i)}));return o.error&&i(o.value),n.promise}});var uf=Jn,sf=String,cf=function(t){if("Symbol"===uf(t))throw new TypeError("Cannot convert a Symbol value to a string");return sf(t)},lf=A,ff=Mr,hf=cf,df=W,pf=lf("".charAt),vf=lf("".charCodeAt),yf=lf("".slice),mf=function(t){return function(e,n){var r,i,o=hf(df(e)),a=ff(n),u=o.length;return a<0||a>=u?t?"":void 0:(r=vf(o,a))<55296||r>56319||a+1===u||(i=vf(o,a+1))<56320||i>57343?t?pf(o,a):r:t?yf(o,a,a+2):i-56320+(r-55296<<10)+65536}},gf={codeAt:mf(!1),charAt:mf(!0)},bf=gf.charAt,wf=cf,xf=gn,Of=Yl,kf=zl,Sf="String Iterator",jf=xf.set,_f=xf.getterFor(Sf);Of(String,"String",(function(t){jf(this,{type:Sf,string:wf(t),index:0})}),(function(){var t,e=_f(this),n=e.string,r=e.index;return r>=n.length?kf(void 0,!0):(t=bf(n,r),e.index+=t.length,kf(t,!1))}));var Mf={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0},Df=Tt("span").classList,Pf=Df&&Df.constructor&&Df.constructor.prototype,$f=Pf===Object.prototype?void 0:Pf,Ef=m,Lf=Mf,Tf=$f,Cf=Xl,Af=Xe,Rf=Ni,If=gt("iterator"),Nf=Cf.values,Wf=function(t,e){if(t){if(t[If]!==Nf)try{Af(t,If,Nf)}catch(e){t[If]=Nf}if(Rf(t,e,!0),Lf[e])for(var n in Cf)if(t[n]!==Cf[n])try{Af(t,n,Cf[n])}catch(e){t[n]=Cf[n]}}};for(var Yf in Lf)Wf(Ef[Yf]&&Ef[Yf].prototype,Yf);Wf(Tf,"DOMTokenList");var zf=F,Ff=Er,Hf=Rr,Bf=function(t){for(var e=zf(this),n=Hf(e),r=arguments.length,i=Ff(r>1?arguments[1]:void 0,n),o=r>2?arguments[2]:void 0,a=void 0===o?n:Ff(o,n);a>i;)e[i++]=t;return e},Gf=Zc;Si({target:"Array",proto:!0},{fill:Bf}),Gf("fill");var Uf=Gn,qf=Array.isArray||function(t){return"Array"===Uf(t)},Vf=xe,Kf=jt,Zf=Ze,Qf=function(t,e,n){var r=Vf(e);r in t?Kf.f(t,r,Zf(0,n)):t[r]=n},Jf=P,Xf=it,th=gt("species"),eh=function(t){return Xf>=51||!Jf((function(){var e=[];return(e.constructor={})[th]=function(){return{foo:1}},1!==e[t](Boolean).foo}))},nh=Si,rh=qf,ih=po,oh=Pt,ah=Er,uh=Rr,sh=dr,ch=Qf,lh=gt,fh=Ao,hh=eh("slice"),dh=lh("species"),ph=Array,vh=Math.max;function yh(t,e,n,r){return new(n||(n=Promise))((function(i,o){function a(t){try{s(r.next(t))}catch(t){o(t)}}function u(t){try{s(r.throw(t))}catch(t){o(t)}}function s(t){var e;t.done?i(t.value):(e=t.value,e instanceof n?e:new n((function(t){t(e)}))).then(a,u)}s((r=r.apply(t,e||[])).next())}))}function mh(t,e,n,r){if("a"===n&&!r)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof e?t!==e||!r:!e.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===n?r:"a"===n?r.call(t):r?r.value:e.get(t)}nh({target:"Array",proto:!0,forced:!hh},{slice:function(t,e){var n,r,i,o=sh(this),a=uh(o),u=ah(t,a),s=ah(void 0===e?a:e,a);if(rh(o)&&(n=o.constructor,(ih(n)&&(n===ph||rh(n.prototype))||oh(n)&&null===(n=n[dh]))&&(n=void 0),n===ph||void 0===n))return fh(o,u,s);for(r=new(void 0===n?ph:n)(vh(s-u,0)),i=0;ug;g++)if((u||g in v)&&(d=m(h=v[g],g,p),t))if(e)w[g]=d;else if(d)switch(t){case 3:return!0;case 5:return h;case 6:return g;case 2:Ch(w,h)}else switch(t){case 4:return!1;case 7:Ch(w,h)}return o?-1:r||i?i:w}},Rh={forEach:Ah(0),map:Ah(1),filter:Ah(2),some:Ah(3),every:Ah(4),find:Ah(5),findIndex:Ah(6),filterReject:Ah(7)},Ih=Rh.map;Si({target:"Array",proto:!0,forced:!eh("map")},{map:function(t){return Ih(this,t,arguments.length>1?arguments[1]:void 0)}});var Nh=_t,Wh=A,Yh=Ht,zh=P,Fh=wc,Hh=Qr,Bh=nr,Gh=F,Uh=lr,qh=Object.assign,Vh=Object.defineProperty,Kh=Wh([].concat),Zh=!qh||zh((function(){if(Nh&&1!==qh({b:1},qh(Vh({},"a",{enumerable:!0,get:function(){Vh(this,"b",{value:3,enumerable:!1})}}),{b:2})).b)return!0;var t={},e={},n=Symbol("assign detection"),r="abcdefghijklmnopqrst";return t[n]=7,r.split("").forEach((function(t){e[t]=t})),7!==qh({},t)[n]||Fh(qh({},e)).join("")!==r}))?function(t,e){for(var n=Gh(t),r=arguments.length,i=1,o=Hh.f,a=Bh.f;r>i;)for(var u,s=Uh(arguments[i++]),c=o?Kh(Fh(s),o(s)):Fh(s),l=c.length,f=0;l>f;)u=c[f++],Nh&&!Yh(a,s,u)||(n[u]=s[u]);return n}:qh,Qh=Zh;Si({target:"Object",stat:!0,arity:2,forced:Object.assign!==Qh},{assign:Qh});var Jh={exports:{}},Xh={},td=Er,ed=Rr,nd=Qf,rd=Array,id=Math.max,od=function(t,e,n){for(var r=ed(t),i=td(e,r),o=td(void 0===n?r:n,r),a=rd(id(o-i,0)),u=0;i1&&void 0!==arguments[1]?arguments[1]:wp.SCROLL_NONE,r=this.calendar.options.options,i=this.calendar.templateCollection,o=r.date.min?i.get(r.domain.type).extractUnit(+r.date.min):void 0,a=r.date.max?i.get(r.domain.type).extractUnit(+r.date.max):void 0,u=this.calendar.domainCollection;return mh(this,kp,"m",Sp).call(this,t,o,a,n)?wp.SCROLL_NONE:(n!==wp.SCROLL_NONE&&t.clamp(o,a).slice(r.range,n===wp.SCROLL_FORWARD),u.merge(t,r.range,(function(n,o){var a=null;return a=t.at(o+1)?t.at(o+1):e.calendar.dateHelper.intervals(r.domain.type,n,2).pop(),i.get(r.subDomain.type).mapping(n,a).map((function(t){return Object.assign(Object.assign({},t),{v:r.data.defaultValue})}))})),mh(this,kp,"m",jp).call(this,u.min,u.max,o,a),n===wp.SCROLL_BACKWARD?this.calendar.eventEmitter.emit("domainsLoaded",[u.min]):n===wp.SCROLL_FORWARD&&this.calendar.eventEmitter.emit("domainsLoaded",[u.max]),n)}},{key:"jumpTo",value:function(t,e){var n=this.calendar,r=n.domainCollection,i=n.options,o=new Date(r.min),a=new Date(r.max);return ta?this.loadNewDomains(this.calendar.createDomainCollection(a,t,!1),wp.SCROLL_FORWARD):wp.SCROLL_NONE}}]),t}();kp=new WeakSet,Sp=function(t,e,n,r){return!!(n&&t.max>=n&&this.maxDomainReached&&r===wp.SCROLL_FORWARD)||!!(e&&t.min<=e&&this.minDomainReached&&r===wp.SCROLL_BACKWARD)},jp=function(t,e,n,r){if(n){var i=t<=n;this.calendar.eventEmitter.emit(i?"minDateReached":"minDateNotReached"),this.minDomainReached=i}if(r){var o=e>=r;this.calendar.eventEmitter.emit(o?"maxDateReached":"maxDateNotReached"),this.maxDomainReached=o}};var Pp=TypeError,$p=Si,Ep=P,Lp=qf,Tp=Pt,Cp=F,Ap=Rr,Rp=function(t){if(t>9007199254740991)throw Pp("Maximum allowed index exceeded");return t},Ip=Qf,Np=Dh,Wp=eh,Yp=it,zp=gt("isConcatSpreadable"),Fp=Yp>=51||!Ep((function(){var t=[];return t[zp]=!1,t.concat()[0]!==t})),Hp=function(t){if(!Tp(t))return!1;var e=t[zp];return void 0!==e?!!e:Lp(t)};$p({target:"Array",proto:!0,arity:1,forced:!Fp||!Wp("concat")},{concat:function(t){var e,n,r,i,o,a=Cp(this),u=Np(a,0),s=0;for(e=-1,r=arguments.length;e1?arguments[1]:void 0);e=e?e.next:n.first;)for(r(e.value,e.key,this);e&&e.removed;)e=e.previous},has:function(t){return!!s(this,t)}}),Xp(o,n?{get:function(t){var e=s(this,t);return e&&e.value},set:function(t,e){return u(this,0===t?0:t,e)}}:{add:function(t){return u(this,t=0===t?0:t,t)}}),uv&&Jp(o,"size",{configurable:!0,get:function(){return a(this).size}}),i},setStrong:function(t,e,n){var r=e+" Iterator",i=lv(e),o=lv(r);iv(t,e,(function(t,e){cv(this,{type:r,target:t,state:i(t),kind:e,last:void 0})}),(function(){for(var t=o(this),e=t.kind,n=t.last;n&&n.removed;)n=n.previous;return t.target&&(t.last=n=n?n.next:t.state.first)?ov("keys"===e?n.key:"values"===e?n.value:[n.key,n.value],!1):(t.target=void 0,ov(void 0,!0))}),n?"entries":"values",!n,!0),av(e)}};Xd("Map",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),fv);var hv=te,dv=TypeError,pv=od,vv=Math.floor,yv=function(t,e){var n=t.length,r=vv(n/2);return n<8?mv(t,e):gv(t,yv(pv(t,0,r),e),yv(pv(t,r),e),e)},mv=function(t,e){for(var n,r,i=t.length,o=1;o0;)t[r]=t[--r];r!==o++&&(t[r]=n)}return t},gv=function(t,e,n,r){for(var i=e.length,o=n.length,a=0,u=0;a3)){if(Rv)return!0;if(Nv)return Nv<603;var t,e,n,r,i="";for(t=65;t<76;t++){switch(e=String.fromCharCode(t),t){case 66:case 69:case 70:case 72:n=3;break;case 68:case 71:n=4;break;default:n=2}for(r=0;r<47;r++)Wv.push({k:e+r,v:n})}for(Wv.sort((function(t,e){return e.v-t.v})),r=0;rEv(n)?1:-1}}(t)),n=Pv(i),r=0;r1?arguments[1]:void 0)},Qv=m,Jv=Mf,Xv=$f,ty=Zv,ey=Xe,ny=function(t){if(t&&t.forEach!==ty)try{ey(t,"forEach",ty)}catch(e){t.forEach=ty}};for(var ry in Jv)Jv[ry]&&ny(Qv[ry]&&Qv[ry].prototype);function iy(t){return"top"===t||"bottom"===t}function oy(t){return t[xp.LEFT]+t[xp.RIGHT]}function ay(t){return t[xp.TOP]+t[xp.BOTTOM]}ny(Xv);var uy,sy,cy=function(){function t(e,n){a(this,t),Uv.add(this),this.calendar=e,this.domainPainter=n,this.collection=new Map,this.scrollDirection=wp.SCROLL_FORWARD}return s(t,[{key:"get",value:function(t){return this.collection.get(t)}},{key:"update",value:function(t,e){var n=this,r=this.calendar.options.options,i=r.verticalOrientation,o=r.domain;this.scrollDirection=e;var a={width:0,height:0},u=0,s=e===wp.SCROLL_FORWARD?-1:1,c=t.keys;return"desc"===this.calendar.options.options.domain.sort&&(c.reverse(),s*=-1),t.yankedDomains.forEach((function(t){u+=n.collection.get(t)[i?"height":"width"]})),t.yankedDomains.forEach((function(t){var e=n.collection.get(t);n.collection.set(t,Object.assign(Object.assign({},e),{x:i?e.x:e.x+u*s,y:i?e.y+u*s:e.y}))})),c.forEach((function(t){var e=mh(n,Uv,"m",qv).call(n,t),r=mh(n,Uv,"m",Vv).call(n,t);i?(a.height+=r,a.width=Math.max(e,a.width)):(a.width+=e,a.height=Math.max(r,a.height));var c=a.width-e,l=a.height-r;n.collection.set(t,Object.assign(Object.assign({},n.collection.get(t)),{x:i?0:c,y:i?l:0,pre_x:i?c:c-u*s,pre_y:i?l-u*s:l,width:e,height:r,inner_width:e-(i?0:o.gutter),inner_height:r-(i?o.gutter:0)}))})),a}}]),t}();Uv=new WeakSet,qv=function(t){var e=this.calendar.options.options,n=e.domain,r=e.subDomain,i=e.x,o=e.verticalOrientation,a=this.calendar.templateCollection.get(r.type).columnsCount(t),u=(r.width+r.gutter)*a-r.gutter;return oy(n.padding)+i.domainHorizontalLabelWidth+(o?0:n.gutter)+u},Vv=function(t){var e=this.calendar.options.options,n=e.domain,r=e.subDomain,i=e.x,o=e.verticalOrientation,a=this.calendar.templateCollection.get(r.type).rowsCount(t),u=(r.height+r.gutter)*a-r.gutter;return ay(n.padding)+u+(o?n.gutter:0)+i.domainVerticalLabelHeight};var ly=".ch-domain",fy=function(){function t(e){a(this,t),uy.add(this),this.calendar=e,this.coordinates=new cy(e,this),this.root=null,this.dimensions={width:0,height:0}}return s(t,[{key:"paint",value:function(t,e){var n=this,r=this.calendar.options.options.animationDuration,i=e.transition().duration(r),o=this.coordinates;this.dimensions=o.update(this.calendar.domainCollection,t);var a=[];return this.root=e.selectAll(ly).data(this.calendar.domainCollection.keys,(function(t){return t})).join((function(t){return t.append("svg").attr("x",(function(t){return o.get(t).pre_x})).attr("y",(function(t){return o.get(t).pre_y})).attr("width",(function(t){return o.get(t).inner_width})).attr("height",(function(t){return o.get(t).inner_height})).attr("class",(function(t){return mh(n,uy,"m",sy).call(n,t)})).call((function(t){return t.append("rect").attr("width",(function(t){return o.get(t).inner_width})).attr("height",(function(t){return o.get(t).inner_height})).attr("class","".concat(ly.slice(1),"-bg"))})).call((function(t){return a.push(t.transition(i).attr("x",(function(t){return o.get(t).x})).attr("y",(function(t){return o.get(t).y})).end())}))}),(function(t){return t.call((function(t){return a.push(t.transition(i).attr("x",(function(t){return o.get(t).x})).attr("y",(function(t){return o.get(t).y})).attr("width",(function(t){return o.get(t).inner_width})).attr("height",(function(t){return o.get(t).inner_height})).end())})).call((function(t){return a.push(t.selectAll("".concat(ly,"-bg")).transition(i).attr("width",(function(t){return o.get(t).inner_width})).attr("height",(function(t){return o.get(t).inner_height})).end())}))}),(function(t){return t.call((function(t){return a.push(t.transition(i).attr("x",(function(t){return o.get(t).x})).attr("y",(function(t){return o.get(t).y})).remove().end())}))})),a}}]),t}();uy=new WeakSet,sy=function(t){var e=ly.slice(1),n=this.calendar.dateHelper.date(t);switch(this.calendar.options.options.domain.type){case"hour":e+=" h_".concat(n.hour());break;case"day":e+=" d_".concat(n.date()," dy_").concat(n.format("d")+1);break;case"week":e+=" w_".concat(n.week());break;case"month":e+=" m_".concat(n.month()+1);break;case"year":e+=" y_".concat(n.year())}return e};var hy=zr.includes,dy=Zc;Si({target:"Array",proto:!0,forced:P((function(){return!Array(1).includes()}))},{includes:function(t){return hy(this,t,arguments.length>1?arguments[1]:void 0)}}),dy("includes");var py=Rh.filter;Si({target:"Array",proto:!0,forced:!eh("filter")},{filter:function(t){return py(this,t,arguments.length>1?arguments[1]:void 0)}});var vy,yy,my,gy,by=Yt,wy=ks,xy=To,Oy=Ht,ky=F,Sy=function(t,e,n,r){try{return r?e(by(n)[0],n[1]):e(n)}catch(e){wy(t,"throw",e)}},jy=as,_y=po,My=Rr,Dy=Qf,Py=bs,$y=hs,Ey=Array,Ly=function(t){var e=ky(t),n=_y(this),r=arguments.length,i=r>1?arguments[1]:void 0,o=void 0!==i;o&&(i=xy(i,r>2?arguments[2]:void 0));var a,u,s,c,l,f,h=$y(e),d=0;if(!h||this===Ey&&jy(h))for(a=My(e),u=n?new this(a):Ey(a);a>d;d++)f=o?i(e[d],d):e[d],Dy(u,d,f);else for(l=(c=Py(e,h)).next,u=n?new this:[];!(s=Oy(l,c)).done;d++)f=o?Sy(c,i,[s.value,d],!0):s.value,Dy(u,d,f);return u.length=d,u};Si({target:"Array",stat:!0,forced:!Fs((function(t){Array.from(t)}))},{from:Ly});var Ty,Cy,Ay,Ry,Iy,Ny,Wy,Yy={year:"YYYY",month:"MMMM",week:"wo [week] YYYY",xDay:"Do MMM",ghDay:"Do MMM",day:"Do MMM",hour:"HH:00",minute:"HH:mm"},zy=function(){function t(e,n,r,i){var o=arguments.length>4&&void 0!==arguments[4]&&arguments[4];if(a(this,t),vy.add(this),this.collection=new Map,this.dateHelper=e,n&&r&&i){var u=this.dateHelper.intervals(n,r,i,o).map((function(t){return xh(t)}));this.collection=new Map(u)}this.min=0,this.max=0,this.keys=[],this.yankedDomains=[],this.collection.size>0&&mh(this,vy,"m",gy).call(this)}return s(t,[{key:"has",value:function(t){return this.collection.has(t)}},{key:"get",value:function(t){return this.collection.get(t)}},{key:"forEach",value:function(t){return this.collection.forEach(t)}},{key:"at",value:function(t){return this.keys[t]}},{key:"clamp",value:function(t,e){var n=this;return t&&this.mine&&this.keys.filter((function(t){return t>e})).forEach((function(t){return n.collection.delete(t)})),mh(this,vy,"m",gy).call(this),this}},{key:"merge",value:function(t,e,n){var r=this;this.yankedDomains=[],t.keys.forEach((function(t,i){if(!r.has(t)){if(r.collection.size>=e){var o=r.max;t>r.max&&(o=r.min),o&&r.collection.delete(o)&&r.yankedDomains.push(o)}r.collection.set(t,n(t,i)),mh(r,vy,"m",gy).call(r)}})),this.yankedDomains=this.yankedDomains.sort((function(t,e){return t-e}))}},{key:"slice",value:function(){var t=this,e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=!(arguments.length>1&&void 0!==arguments[1])||arguments[1];this.keys.length>e&&((n?this.keys.slice(0,-e):this.keys.slice(e)).forEach((function(e){t.collection.delete(e)})),mh(this,vy,"m",gy).call(this));return this}},{key:"fill",value:function(t,e,n){var r=this,i=e.x,o=e.y,a=e.groupY,u=e.defaultValue,s=this.groupRecords(t,i,n);this.keys.forEach((function(t){var e=s.get(t)||{};mh(r,vy,"m",yy).call(r,t,e,o,a,u)}))}},{key:"groupRecords",value:function(t,e,n){var r=this,i=new Map,o=new Map;return this.keys.forEach((function(t){r.get(t).forEach((function(e){o.set(e.t,t)}))})),t.forEach((function(t){var a=r.extractTimestamp(t,e,n);if(o.has(a)){var u=o.get(a),s=i.get(u)||{};s[a]||(s[a]=[]),s[a].push(t),i.set(u,s)}})),i}},{key:"groupValues",value:function(t,e){var n=t.filter((function(t){return null!==t}));if("string"==typeof e){if(n.every((function(t){return"number"==typeof t})))switch(e){case"sum":return n.reduce((function(t,e){return t+e}),0);case"count":return n.length;case"min":return Math.min.apply(Math,l(n))||null;case"max":return Math.max.apply(Math,l(n))||null;case"average":return n.length>0?n.reduce((function(t,e){return t+e}),0)/n.length:null;default:return null}return"count"===e?n.length:null}return"function"==typeof e?e(n):null}},{key:"extractTimestamp",value:function(t,e,n){var r="function"==typeof e?e(t):t[e];return"string"==typeof r&&(r=+new Date(r)),n(r)}}]),t}();vy=new WeakSet,yy=function(t,e,n,r,i){var o=this;this.get(t).forEach((function(a,u){var s=i;e.hasOwnProperty(a.t)&&(s=o.groupValues(mh(o,vy,"m",my).call(o,e[a.t],n),r)),o.get(t)[u].v=s}))},my=function(t,e){return t.map((function(t){return"function"==typeof e?e(t):t[e]}))},gy=function(){this.keys=Array.from(this.collection.keys()).map((function(t){return parseInt(t,10)})).sort((function(t,e){return t-e}));var t=this.keys;return this.min=t[0],this.max=t[t.length-1],this.keys};var Fy=".ch-domain-text",Hy=function(){function t(e){a(this,t),Ty.add(this),this.calendar=e}return s(t,[{key:"paint",value:function(t){var e=this,n=this.calendar.options.options.domain,r=n.label,i=n.type,o=this.calendar.dateHelper,a=r.text;null!==a&&""!==a&&(void 0===a&&(a=Yy[i]),t.selectAll(Fy).data((function(t){return[t]}),(function(t){return t})).join((function(t){return t.append("text").attr("class",Fy.slice(1)).attr("x",(function(t){return mh(e,Ty,"m",Ay).call(e,t)})).attr("y",(function(t){return mh(e,Ty,"m",Ry).call(e,t)})).attr("text-anchor",r.textAlign).attr("dominant-baseline",(function(){return mh(e,Ty,"m",Cy).call(e)})).text((function(t,e,n){return o.format(t,a,n[e])})).call((function(t){return mh(e,Ty,"m",Wy).call(e,t)}))}),(function(t){t.attr("x",(function(t){return mh(e,Ty,"m",Ay).call(e,t)})).attr("y",(function(t){return mh(e,Ty,"m",Ry).call(e,t)})).attr("text-anchor",r.textAlign).attr("dominant-baseline",(function(){return mh(e,Ty,"m",Cy).call(e)})).text((function(t,e,n){return o.format(t,a,n[e])})).call((function(t){return mh(e,Ty,"m",Wy).call(e,t)}))})))}}]),t}();Ty=new WeakSet,Cy=function(){var t=this.calendar.options.options.domain.label,e=t.position,n=t.rotate;return iy(e)?"middle":"left"===n&&"left"===e||"right"===n&&"right"===e?"bottom":"hanging"},Ay=function(t){var e=this.calendar.options.options.domain,n=e.padding,r=e.label,i=r.position,o=r.textAlign,a=r.offset,u=this.calendar.options.options.x.domainHorizontalLabelWidth,s=n[xp.LEFT];return"right"===i&&(s+=mh(this,Ty,"m",Iy).call(this,t)),"middle"===o&&(["top","bottom"].includes(i)?s+=mh(this,Ty,"m",Iy).call(this,t)/2:s+=u/2),"end"===o&&(iy(i)?s+=mh(this,Ty,"m",Iy).call(this,t):s+=u),s+a.x},Ry=function(t){var e=this.calendar.options.options,n=e.domain,r=n.label,i=r.position,o=r.offset,a=n.padding,u=e.x,s=a[xp.TOP]+u.domainVerticalLabelHeight/2;return"bottom"===i&&(s+=mh(this,Ty,"m",Ny).call(this,t)),s+o.y},Iy=function(t){var e=this.calendar.options.options,n=e.domain.padding,r=e.x.domainHorizontalLabelWidth;return this.calendar.calendarPainter.domainsContainerPainter.domainPainter.coordinates.get(t).inner_width-r-oy(n)},Ny=function(t){var e=this.calendar.options.options,n=e.x.domainVerticalLabelHeight,r=e.domain.padding;return this.calendar.calendarPainter.domainsContainerPainter.domainPainter.coordinates.get(t).inner_height-n-ay(r)},Wy=function(t){var e=this,n=this.calendar.options.options,r=n.domain.label,i=r.rotate,o=r.textAlign,a=r.position,u=n.x.domainHorizontalLabelWidth;switch(i){case"right":t.attr("transform",(function(t){var n=mh(e,Ty,"m",Iy).call(e,t),r=mh(e,Ty,"m",Ny).call(e,t),i=["rotate(90, ".concat("right"===a?n:u,", 0)")];switch(a){case"right":"middle"===o?i.push("translate(".concat(r/2-u/2,")")):"end"===o&&i.push("translate(".concat(r-u,")"));break;case"left":"start"===o?i.push("translate(".concat(u,")")):"middle"===o?i.push("translate(".concat(u/2+r/2,")")):"end"===o&&i.push("translate(".concat(r,")"))}return i.join(",")}));break;case"left":t.attr("transform",(function(t){var n=mh(e,Ty,"m",Iy).call(e,t),r=mh(e,Ty,"m",Ny).call(e,t),i=["rotate(270, ".concat("right"===a?n:u,", 0)")];switch(a){case"right":"start"===o?i.push("translate(-".concat(r,")")):"middle"===o?i.push("translate(-".concat(r/2+u/2,")")):"end"===o&&i.push("translate(-".concat(u,")"));break;case"left":"start"===o?i.push("translate(".concat(u-r,")")):"middle"===o&&i.push("translate(".concat(u/2-r/2,")"))}return i.join(",")}))}};var By,Gy,Uy,qy,Vy,Ky,Zy,Qy="\t\n\v\f\r                　\u2028\u2029\ufeff",Jy=W,Xy=cf,tm=Qy,em=A("".replace),nm=RegExp("^["+tm+"]+"),rm=RegExp("(^|[^"+tm+"])["+tm+"]+$"),im=function(t){return function(e){var n=Xy(Jy(e));return 1&t&&(n=em(n,nm,"")),2&t&&(n=em(n,rm,"$1")),n}},om={start:im(1),end:im(2),trim:im(3)},am=We.PROPER,um=P,sm=Qy,cm=om.trim;Si({target:"String",proto:!0,forced:function(t){return um((function(){return!!sm[t]()||"​…᠎"!=="​…᠎"[t]()||am&&sm[t].name!==t}))}("trim")},{trim:function(){return cm(this)}});var lm,fm,hm,dm,pm=".ch-subdomain",vm=function(){function t(e){a(this,t),By.add(this),this.calendar=e,this.root=null}return s(t,[{key:"paint",value:function(t){var e=this;this.root=t||this.root;var n="".concat(pm,"-container"),r=this.root.selectAll(n).data((function(t){return[t]}),(function(t){return t})).join((function(t){return t.append("svg").call((function(t){return mh(e,By,"m",Gy).call(e,t)})).attr("class",n.slice(1))}),(function(t){return t.call((function(t){return mh(e,By,"m",Gy).call(e,t)}))})),i=this.calendar.options.options.subDomain,o=i.radius,a=i.width,u=i.height,s=i.sort,c=this.calendar.eventEmitter;r.selectAll("g").data((function(t){var n=e.calendar.domainCollection.get(t);if("desc"===s){var r=Math.max.apply(Math,l(n.map((function(t){return t.x}))));n.forEach((function(t,e){n[e].x=Math.abs(t.x-r)}))}return n})).join((function(t){return t.append("g").call((function(t){return t.insert("rect").attr("class",(function(t){return mh(e,By,"m",Uy).call(e,t.t,"".concat(pm.slice(1),"-bg"))})).attr("width",a).attr("height",u).attr("x",(function(t){return mh(e,By,"m",Ky).call(e,t)})).attr("y",(function(t){return mh(e,By,"m",Zy).call(e,t)})).on("click",(function(t,e){return c.emit("click",t,e.t,e.v)})).on("mouseover",(function(t,e){return c.emit("mouseover",t,e.t,e.v)})).on("mouseout",(function(t,e){return c.emit("mouseout",t,e.t,e.v)})).attr("rx",o>0?o:null).attr("ry",o>0?o:null)})).call((function(t){return mh(e,By,"m",qy).call(e,t)}))}),(function(t){return t.selectAll("rect").attr("class",(function(t){return mh(e,By,"m",Uy).call(e,t.t,"".concat(pm.slice(1),"-bg"))})).attr("width",a).attr("height",u).attr("x",(function(t){return mh(e,By,"m",Ky).call(e,t)})).attr("y",(function(t){return mh(e,By,"m",Zy).call(e,t)})).attr("rx",o).attr("ry",o)}))}}]),t}();By=new WeakSet,Gy=function(t){var e=this.calendar.options.options,n=e.domain,r=n.padding,i=n.label.position;t.attr("x",(function(){var t=r[xp.LEFT];return"left"===i&&(t+=e.x.domainHorizontalLabelWidth),t})).attr("y",(function(){var t=r[xp.TOP];return"top"===i&&(t+=e.x.domainVerticalLabelHeight),t}))},Uy=function(t){var e=this,n=this.calendar.options.options,r=n.date.highlight,i=n.subDomain.type,o="";r.length>0&&r.forEach((function(n){var r=e.calendar.templateCollection.get(i).extractUnit;r(+n)===r(t)&&(o="highlight")}));for(var a=arguments.length,u=new Array(a>1?a-1:0),s=1;s0&&void 0!==arguments[0]?arguments[0]:wp.SCROLL_NONE,e=this.domainsContainerPainter.paint(t).concat(this.pluginPainter.paint()).concat(this.domainsContainerPainter.updatePosition());return mh(this,bm,"m",Om).call(this),Promise.allSettled(e)}},{key:"destroy",value:function(){var t=this.calendar.pluginManager.destroyAll().concat(this.domainsContainerPainter.destroy());return this.root?(t.push(this.root.transition().duration(this.calendar.options.options.animationDuration).attr("width",0).attr("height",0).remove().end()),Promise.allSettled(t)):Promise.allSettled(t)}}]),e}();bm=new WeakSet,wm=function(){return this.domainsContainerPainter.height()+this.pluginPainter.insideHeight()},xm=function(){return this.domainsContainerPainter.width()+this.pluginPainter.insideWidth()},Om=function(){var t=this.calendar.options.options,e=mh(this,bm,"m",xm).call(this),n=mh(this,bm,"m",wm).call(this);this.root.transition().duration(t.animationDuration).attr("width",e).attr("height",n),e===this.dimensions.width&&n===this.dimensions.height||this.calendar.eventEmitter.emit("resize",e,n,this.dimensions.width,this.dimensions.height),this.dimensions={width:e,height:n}};var jm="object"==typeof global&&global&&global.Object===Object&&global,_m="object"==typeof self&&self&&self.Object===Object&&self,Mm=jm||_m||Function("return this")(),Dm=Mm.Symbol,Pm=Object.prototype,$m=Pm.hasOwnProperty,Em=Pm.toString,Lm=Dm?Dm.toStringTag:void 0;var Tm=Object.prototype.toString;var Cm="[object Null]",Am="[object Undefined]",Rm=Dm?Dm.toStringTag:void 0;function Im(t){return null==t?void 0===t?Am:Cm:Rm&&Rm in Object(t)?function(t){var e=$m.call(t,Lm),n=t[Lm];try{t[Lm]=void 0;var r=!0}catch(t){}var i=Em.call(t);return r&&(e?t[Lm]=n:delete t[Lm]),i}(t):function(t){return Tm.call(t)}(t)}function Nm(t){var e=typeof t;return null!=t&&("object"==e||"function"==e)}var Wm="[object AsyncFunction]",Ym="[object Function]",zm="[object GeneratorFunction]",Fm="[object Proxy]";function Hm(t){if(!Nm(t))return!1;var e=Im(t);return e==Ym||e==zm||e==Wm||e==Fm}var Bm=F,Gm=wc;Si({target:"Object",stat:!0,forced:P((function(){Gm(1)}))},{keys:function(t){return Gm(Bm(t))}});var Um,qm=Pt,Vm=Gn,Km=gt("match"),Zm=function(t){var e;return qm(t)&&(void 0!==(e=t[Km])?!!e:"RegExp"===Vm(t))},Qm=TypeError,Jm=function(t){if(Zm(t))throw new Qm("The method doesn't accept regular expressions");return t},Xm=gt("match"),tg=function(t){var e=/./;try{"/./"[t](e)}catch(n){try{return e[Xm]=!1,"/./"[t](e)}catch(t){}}return!1},eg=Si,ng=Po,rg=er.f,ig=Cr,og=cf,ag=Jm,ug=W,sg=tg,cg=ng("".startsWith),lg=ng("".slice),fg=Math.min,hg=sg("startsWith");eg({target:"String",proto:!0,forced:!!(hg||(Um=rg(String.prototype,"startsWith"),!Um||Um.writable))&&!hg},{startsWith:function(t){var e=og(ug(this));ag(t);var n=ig(fg(arguments.length>1?arguments[1]:void 0,e.length)),r=og(t);return cg?cg(e,r,n):lg(e,n,n+r.length)===r}});var dg=_t,pg=P,vg=A,yg=ol,mg=wc,gg=dr,bg=vg(nr.f),wg=vg([].push),xg=dg&&pg((function(){var t=Object.create(null);return t[2]=2,!bg(t,2)})),Og=function(t){return function(e){for(var n,r=gg(e),i=mg(r),o=xg&&null===yg(r),a=i.length,u=0,s=[];a>u;)n=i[u++],dg&&!(o?n in r:bg(r,n))||wg(s,t?[n,r[n]]:r[n]);return s}},kg={entries:Og(!0),values:Og(!1)}.entries;function Sg(t){return null!=t&&!Number.isNaN(t)}function jg(t,e){return+Sg(e)-+Sg(t)||n.ascending(t,e)}function _g(t){return isFinite(t)?t:NaN}function Mg(t){return t>0&&isFinite(t)?t:NaN}function Dg(t){return t<0&&isFinite(t)?t:NaN}Si({target:"Object",stat:!0},{entries:function(t){return kg(t)}});const Pg=/^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/;function $g(t,e){return Pg.test(t+="")?new Date(t):"function"==typeof e?e(t):e}const Eg=new Map([["second",n.timeSecond],["minute",n.timeMinute],["hour",n.timeHour],["day",n.timeDay],["week",n.timeWeek],["month",n.timeMonth],["quarter",n.timeMonth.every(3)],["half",n.timeMonth.every(6)],["year",n.timeYear],["monday",n.timeMonday],["tuesday",n.timeTuesday],["wednesday",n.timeWednesday],["thursday",n.timeThursday],["friday",n.timeFriday],["saturday",n.timeSaturday],["sunday",n.timeSunday]]),Lg=new Map([["second",n.utcSecond],["minute",n.utcMinute],["hour",n.utcHour],["day",n.utcDay],["week",n.utcWeek],["month",n.utcMonth],["quarter",n.utcMonth.every(3)],["half",n.utcMonth.every(6)],["year",n.utcYear],["monday",n.utcMonday],["tuesday",n.utcTuesday],["wednesday",n.utcWednesday],["thursday",n.utcThursday],["friday",n.utcFriday],["saturday",n.utcSaturday],["sunday",n.utcSunday]]);function Tg(t){const e=Eg.get(`${t}`.toLowerCase());if(!e)throw new Error(`unknown interval: ${t}`);return e}function Cg(t){const e=Lg.get(`${t}`.toLowerCase());if(!e)throw new Error(`unknown interval: ${t}`);return e}const Ag=Object.getPrototypeOf(Uint8Array),Rg=Object.prototype.toString,Ig=t=>()=>t;function Ng(t){return t instanceof Ag?t:Hg(t,Wg,Float64Array)}function Wg(t){return null==t?NaN:Number(t)}function Yg(t){return Hg(t,zg)}function zg(t){return t instanceof Date&&!isNaN(t)?t:"string"==typeof t?$g(t):null==t||isNaN(t=+t)?void 0:new Date(t)}function Fg(t){return null==t||t instanceof Array||t instanceof Ag?t:Array.from(t)}function Hg(t,e,n=Array){return null==t?t:t instanceof n?t.map(e):n.from(t,e)}function Bg(t,e=Array){return t instanceof e?t.slice():e.from(t)}function Gg(t){return function(t){return t?.toString===Rg}(t)&&(void 0!==t.type||void 0!==t.domain)}function Ug(t,e){if(null!=t){if("number"==typeof t){0Math.floor(t*e)/e,offset:t=>(t*e+1)/e,range:(t,r)=>n.range(Math.ceil(t*e),r*e).map((t=>t/e))}:{floor:t=>Math.floor(t/e)*e,offset:t=>t+e,range:(t,r)=>n.range(Math.ceil(t/e),r/e).map((t=>t*e))}}if("string"==typeof t)return("time"===e?Tg:Cg)(t);if("function"!=typeof t.floor)throw new Error("invalid interval; missing floor method");if("function"!=typeof t.offset)throw new Error("invalid interval; missing offset method");return t}}function qg(t,e){if((t=Ug(t,e))&&"function"!=typeof t.range)throw new Error("invalid interval: missing range method");return t}function Vg(t){for(const e of t){if(null==e)continue;const t=typeof e;return"string"===t||"boolean"===t}}function Kg(t){for(const e of t)if(null!=e)return e instanceof Date}function Zg(t){for(const e of t)if(null!=e)return"string"==typeof e&&isNaN(e)&&$g(e)}function Qg(t){for(const e of t)if(null!=e){if("string"!=typeof e)return!1;if(e.trim())return!isNaN(e)}}function Jg(t){if(null==t)return;const e=t[0],r=t[t.length-1];return n.descending(e,r)}const Xg=Symbol("position"),tb=Symbol("color"),eb=Symbol("radius"),nb=Symbol("length"),rb=Symbol("opacity"),ib=Symbol("symbol"),ob=new Map([["x",Xg],["y",Xg],["fx",Xg],["fy",Xg],["r",eb],["color",tb],["opacity",rb],["symbol",ib],["length",nb]]),ab=2/Math.sqrt(3),ub={draw(t,e){const n=Math.sqrt(e/Math.PI),r=n*ab,i=r/2;t.moveTo(0,r),t.lineTo(n,i),t.lineTo(n,-i),t.lineTo(0,-r),t.lineTo(-n,-i),t.lineTo(-n,i),t.closePath()}},sb=new Map([["asterisk",n.symbolAsterisk],["circle",n.symbolCircle],["cross",n.symbolCross],["diamond",n.symbolDiamond],["diamond2",n.symbolDiamond2],["hexagon",ub],["plus",n.symbolPlus],["square",n.symbolSquare],["square2",n.symbolSquare2],["star",n.symbolStar],["times",n.symbolTimes],["triangle",n.symbolTriangle],["triangle2",n.symbolTriangle2],["wye",n.symbolWye]]);function cb(t){if(null==t||function(t){return t&&"function"==typeof t.draw}(t))return t;const e=sb.get(`${t}`.toLowerCase());if(e)return e;throw new Error(`invalid symbol: ${t}`)}function lb(t){console.warn(t)}const fb=new Map([["accent",n.schemeAccent],["category10",n.schemeCategory10],["dark2",n.schemeDark2],["paired",n.schemePaired],["pastel1",n.schemePastel1],["pastel2",n.schemePastel2],["set1",n.schemeSet1],["set2",n.schemeSet2],["set3",n.schemeSet3],["tableau10",n.schemeTableau10],["brbg",db(n.schemeBrBG,n.interpolateBrBG)],["prgn",db(n.schemePRGn,n.interpolatePRGn)],["piyg",db(n.schemePiYG,n.interpolatePiYG)],["puor",db(n.schemePuOr,n.interpolatePuOr)],["rdbu",db(n.schemeRdBu,n.interpolateRdBu)],["rdgy",db(n.schemeRdGy,n.interpolateRdGy)],["rdylbu",db(n.schemeRdYlBu,n.interpolateRdYlBu)],["rdylgn",db(n.schemeRdYlGn,n.interpolateRdYlGn)],["spectral",db(n.schemeSpectral,n.interpolateSpectral)],["burd",pb(n.schemeRdBu,n.interpolateRdBu)],["buylrd",pb(n.schemeRdYlBu,n.interpolateRdYlBu)],["blues",hb(n.schemeBlues,n.interpolateBlues)],["greens",hb(n.schemeGreens,n.interpolateGreens)],["greys",hb(n.schemeGreys,n.interpolateGreys)],["oranges",hb(n.schemeOranges,n.interpolateOranges)],["purples",hb(n.schemePurples,n.interpolatePurples)],["reds",hb(n.schemeReds,n.interpolateReds)],["turbo",vb(n.interpolateTurbo)],["viridis",vb(n.interpolateViridis)],["magma",vb(n.interpolateMagma)],["inferno",vb(n.interpolateInferno)],["plasma",vb(n.interpolatePlasma)],["cividis",vb(n.interpolateCividis)],["cubehelix",vb(n.interpolateCubehelixDefault)],["warm",vb(n.interpolateWarm)],["cool",vb(n.interpolateCool)],["bugn",hb(n.schemeBuGn,n.interpolateBuGn)],["bupu",hb(n.schemeBuPu,n.interpolateBuPu)],["gnbu",hb(n.schemeGnBu,n.interpolateGnBu)],["orrd",hb(n.schemeOrRd,n.interpolateOrRd)],["pubu",hb(n.schemePuBu,n.interpolatePuBu)],["pubugn",hb(n.schemePuBuGn,n.interpolatePuBuGn)],["purd",hb(n.schemePuRd,n.interpolatePuRd)],["rdpu",hb(n.schemeRdPu,n.interpolateRdPu)],["ylgn",hb(n.schemeYlGn,n.interpolateYlGn)],["ylgnbu",hb(n.schemeYlGnBu,n.interpolateYlGnBu)],["ylorbr",hb(n.schemeYlOrBr,n.interpolateYlOrBr)],["ylorrd",hb(n.schemeYlOrRd,n.interpolateYlOrRd)],["rainbow",yb(n.interpolateRainbow)],["sinebow",yb(n.interpolateSinebow)]]);function hb(t,e){return({length:r})=>1===r?[t[3][1]]:2===r?[t[3][1],t[3][2]]:(r=Math.max(3,Math.floor(r)))>9?n.quantize(e,r):t[r]}function db(t,e){return({length:r})=>2===r?[t[3][0],t[3][2]]:(r=Math.max(3,Math.floor(r)))>11?n.quantize(e,r):t[r]}function pb(t,e){return({length:r})=>2===r?[t[3][2],t[3][0]]:(r=Math.max(3,Math.floor(r)))>11?n.quantize((t=>e(1-t)),r):t[r].slice().reverse()}function vb(t){return({length:e})=>n.quantize(t,Math.max(2,Math.floor(e)))}function yb(t){return({length:e})=>n.quantize(t,Math.floor(e)+1).slice(0,-1)}function mb(t){const e=`${t}`.toLowerCase();if(!fb.has(e))throw new Error(`unknown ordinal scheme: ${e}`);return fb.get(e)}function gb(t,e){const n=mb(t),r="function"==typeof n?n({length:e}):n;return r.length!==e?r.slice(0,e):r}const bb=new Map([["brbg",n.interpolateBrBG],["prgn",n.interpolatePRGn],["piyg",n.interpolatePiYG],["puor",n.interpolatePuOr],["rdbu",n.interpolateRdBu],["rdgy",n.interpolateRdGy],["rdylbu",n.interpolateRdYlBu],["rdylgn",n.interpolateRdYlGn],["spectral",n.interpolateSpectral],["burd",t=>n.interpolateRdBu(1-t)],["buylrd",t=>n.interpolateRdYlBu(1-t)],["blues",n.interpolateBlues],["greens",n.interpolateGreens],["greys",n.interpolateGreys],["purples",n.interpolatePurples],["reds",n.interpolateReds],["oranges",n.interpolateOranges],["turbo",n.interpolateTurbo],["viridis",n.interpolateViridis],["magma",n.interpolateMagma],["inferno",n.interpolateInferno],["plasma",n.interpolatePlasma],["cividis",n.interpolateCividis],["cubehelix",n.interpolateCubehelixDefault],["warm",n.interpolateWarm],["cool",n.interpolateCool],["bugn",n.interpolateBuGn],["bupu",n.interpolateBuPu],["gnbu",n.interpolateGnBu],["orrd",n.interpolateOrRd],["pubugn",n.interpolatePuBuGn],["pubu",n.interpolatePuBu],["purd",n.interpolatePuRd],["rdpu",n.interpolateRdPu],["ylgnbu",n.interpolateYlGnBu],["ylgn",n.interpolateYlGn],["ylorbr",n.interpolateYlOrBr],["ylorrd",n.interpolateYlOrRd],["rainbow",n.interpolateRainbow],["sinebow",n.interpolateSinebow]]);function wb(t){const e=`${t}`.toLowerCase();if(!bb.has(e))throw new Error(`unknown quantitative scheme: ${e}`);return bb.get(e)}const xb=new Set(["brbg","prgn","piyg","puor","rdbu","rdgy","rdylbu","rdylgn","spectral","burd","buylrd"]);function Ob(t){return null!=t&&xb.has(`${t}`.toLowerCase())}const kb=t=>e=>t(1-e),Sb=[0,1],jb=new Map([["number",n.interpolateNumber],["rgb",n.interpolateRgb],["hsl",n.interpolateHsl],["hcl",n.interpolateHcl],["lab",n.interpolateLab]]);function _b(t){const e=`${t}`.toLowerCase();if(!jb.has(e))throw new Error(`unknown interpolator: ${e}`);return jb.get(e)}function Mb(t,e,r,{type:i,nice:o,clamp:a,zero:u,domain:s=Eb(t,r),unknown:c,round:l,scheme:f,interval:h,range:d=(ob.get(t)===eb?Tb(r,s):ob.get(t)===nb?Cb(r,s):ob.get(t)===rb?Sb:void 0),interpolate:p=(ob.get(t)===tb?null==f&&void 0!==d?n.interpolateRgb:wb(void 0!==f?f:"cyclical"===i?"rainbow":"turbo"):l?n.interpolateRound:n.interpolateNumber),reverse:v}){if(h=qg(h,i),"cyclical"!==i&&"sequential"!==i||(i="linear"),v=!!v,"function"!=typeof p&&(p=_b(p)),1===p.length?(v&&(p=kb(p),v=!1),void 0===d&&2===(d=Float64Array.from(s,((t,e)=>e/(s.length-1)))).length&&(d=Sb),e.interpolate((d===Sb?Ig:Ib)(p))):e.interpolate(p),u){const[t,e]=n.extent(s);(t>0||e<0)&&(Jg(s=Bg(s))!==Math.sign(t)?s[s.length-1]=0:s[0]=0)}return v&&(s=n.reverse(s)),e.domain(s).unknown(c),o&&(e.nice(function(t,e){return!0===t?void 0:"number"==typeof t?t:function(t,e){if((t=qg(t,e))&&"function"!=typeof t.ceil)throw new Error("invalid interval: missing ceil method");return t}(t,e)}(o,i)),s=e.domain()),void 0!==d&&e.range(d),a&&e.clamp(a),{type:i,domain:s,range:d,scale:e,interpolate:p,interval:h}}function Db(t,e,{exponent:r=1,...i}){return Mb(t,n.scalePow().exponent(r),e,{...i,type:"pow"})}function Pb(t,e,{domain:r=[0],unknown:i,scheme:o="rdylbu",interpolate:a,range:u=(void 0!==a?n.quantize(a,r.length+1):ob.get(t)===tb?gb(o,r.length+1):void 0),reverse:s}){const c=Jg(r=Fg(r));if(!isNaN(c)&&!function(t,e){for(let r=1,i=t.length,o=t[0];rvoid 0===t?t:n.min(t,e))),n.max(t,(({value:t})=>void 0===t?t:n.max(t,e)))]:[0,1]}function Eb(t,e){const n=ob.get(t);return(n===eb||n===rb||n===nb?Lb:$b)(e)}function Lb(t){return[0,t.length?n.max(t,(({value:t})=>void 0===t?t:n.max(t,_g))):1]}function Tb(t,e){const r=t.find((({radius:t})=>void 0!==t));if(void 0!==r)return[0,r.radius];const i=n.quantile(t,.5,(({value:t})=>void 0===t?NaN:n.quantile(t,.25,Mg))),o=e.map((t=>3*Math.sqrt(t/i))),a=30/n.max(o);return a<1?o.map((t=>t*a)):o}function Cb(t,e){const r=n.median(t,(({value:t})=>void 0===t?NaN:n.median(t,Math.abs))),i=e.map((t=>12*t/r)),o=60/n.max(i);return o<1?i.map((t=>t*o)):i}function Ab(t){for(const{value:e}of t)if(void 0!==e)for(let n of e){if(n>0)return $b(t,Mg);if(n<0)return $b(t,Dg)}return[1,10]}function Rb(t){const e=[];for(const{value:n}of t)if(void 0!==n)for(const t of n)e.push(t);return e}function Ib(t){return(e,n)=>r=>t(e+r*(n-e))}function Nb(t,e,r,i,{type:o,nice:a,clamp:u,domain:s=$b(i),unknown:c,pivot:l=0,scheme:f,range:h,symmetric:d=!0,interpolate:p=(ob.get(t)===tb?null==f&&void 0!==h?n.interpolateRgb:wb(void 0!==f?f:"rdbu"):n.interpolateNumber),reverse:v}){l=+l;let[y,m]=s;if(n.descending(y,m)<0&&([y,m]=[m,y],v=!v),y=Math.min(y,l),m=Math.max(m,l),"function"!=typeof p&&(p=_b(p)),void 0!==h&&(p=1===p.length?Ib(p)(...h):n.piecewise(p,h)),v&&(p=kb(p)),d){const t=r.apply(l),e=t-r.apply(y),n=r.apply(m)-t;en&&(m=r.invert(t+e))}return e.domain([y,l,m]).unknown(c).interpolator(p),u&&e.clamp(u),a&&e.nice(a),{type:o,domain:[y,m],pivot:l,interpolate:p,scale:e}}function Wb(t,e,{exponent:r=1,...i}){return Nb(t,n.scaleDivergingPow().exponent(r=+r),function(t){return.5===t?Hb:{apply:e=>Math.sign(e)*Math.pow(Math.abs(e),t),invert:e=>Math.sign(e)*Math.pow(Math.abs(e),1/t)}}(r),e,{...i,type:"diverging-pow"})}function Yb(t,e,{constant:r=1,...i}){return Nb(t,n.scaleDivergingSymlog().constant(r=+r),function(t){return{apply:e=>Math.sign(e)*Math.log1p(Math.abs(e/t)),invert:e=>Math.sign(e)*Math.expm1(Math.abs(e))*t}}(r),e,i)}const zb={apply:t=>t,invert:t=>t},Fb={apply:Math.log,invert:Math.exp},Hb={apply:t=>Math.sign(t)*Math.sqrt(Math.abs(t)),invert:t=>Math.sign(t)*(t*t)};function Bb(t,e,n,r){return Mb(t,e,n,r)}const Gb=Symbol("ordinal");function Ub(t,e,r,{type:i,interval:o,domain:a,range:u,reverse:s,hint:c}){return o=qg(o,i),void 0===a&&(a=Kb(r,o,t)),"categorical"!==i&&i!==Gb||(i="ordinal"),s&&(a=n.reverse(a)),e.domain(a),void 0!==u&&("function"==typeof u&&(u=u(a)),e.range(u)),{type:i,domain:a,range:u,scale:e,hint:c,interval:o}}function qb(t,e,{type:r,interval:i,domain:o,range:a,scheme:u,unknown:s,...c}){let l;if(i=qg(i,r),void 0===o&&(o=Kb(e,i,t)),ob.get(t)===ib)l=function(t){return{fill:Zb(t,"fill"),stroke:Zb(t,"stroke")}}(e),a=void 0===a?function(t){return e=t.fill,null==e||function(t){return/^\s*none\s*$/i.test(t)}(e)?n.symbolsStroke:n.symbolsFill;var e}(l):Hg(a,cb);else if(ob.get(t)===tb&&(void 0!==a||"ordinal"!==r&&r!==Gb||(a=function(t,e="greys"){const n=new Set,[r,i]=gb(e,2);for(const e of t)if(null!=e)if(!0===e)n.add(i);else{if(!1!==e)return;n.add(r)}return[...n]}(o,u),void 0!==a&&(u=void 0)),void 0===u&&void 0===a&&(u="ordinal"===r?"turbo":"tableau10"),void 0!==u))if(void 0!==a){const t=wb(u),e=a[0],r=a[1]-a[0];a=({length:i})=>n.quantize((n=>t(e+r*n)),i)}else a=mb(u);if(s===n.scaleImplicit)throw new Error(`implicit unknown on ${t} scale is not supported`);return Ub(t,n.scaleOrdinal().unknown(s),e,{...c,type:r,domain:o,range:a,hint:l})}function Vb(t,e,n,r){let{round:i}=n;return void 0!==i&&t.round(i=!!i),(t=Ub(r,t,e,n)).round=i,t}function Kb(t,e,r){const i=new n.InternSet;for(const{value:e,domain:n}of t){if(void 0!==n)return n();if(void 0!==e)for(const t of e)i.add(t)}if(void 0!==e){const[t,r]=n.extent(i).map(e.floor,e);return e.range(t,e.offset(r))}if(i.size>1e4&&ob.get(r)===Xg)throw new Error(`implicit ordinal domain of ${r} scale has more than 10,000 values`);return n.sort(i,jg)}function Zb(t,e){let n;for(const{hint:r}of t){const t=r?.[e];if(void 0!==t)if(void 0===n)n=t;else if(n!==t)return}return n}function Qb(t,e,r){return function(t,e=[],r={}){const i=function(t,e,{type:n,domain:r,range:i,scheme:o,pivot:a,projection:u}){if("fx"===t||"fy"===t)return"band";"x"!==t&&"y"!==t||null==u||(n=Xb);for(const{type:t}of e)if(void 0!==t)if(void 0===n)n=t;else if(n!==t)throw new Error(`scale incompatible with channel: ${n} !== ${t}`);if(n===Xb)return;if(void 0!==n)return n;if(void 0===r&&!e.some((({value:t})=>void 0!==t)))return;const s=ob.get(t);if(s===eb)return"sqrt";if(s===rb||s===nb)return"linear";if(s===ib)return"ordinal";if((r||i||[]).length>2)return tw(s);if(void 0!==r)return Vg(r)?tw(s):Kg(r)?"utc":s!==tb||null==a&&!Ob(o)?"linear":"diverging";const c=e.map((({value:t})=>t)).filter((t=>void 0!==t));return c.some(Vg)?tw(s):c.some(Kg)?"utc":s!==tb||null==a&&!Ob(o)?"linear":"diverging"}(t,e,r);if(void 0===r.type&&void 0===r.domain&&void 0===r.range&&null==r.interval&&"fx"!==t&&"fy"!==t&&function({type:t}){return"ordinal"===t||"point"===t||"band"===t||t===Gb}({type:i})){const n=e.map((({value:t})=>t)).filter((t=>void 0!==t));n.some(Kg)?lb(`Warning: some data associated with the ${t} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${Jb(i)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${t} scale to "${Jb(i)}".`):n.some(Zg)?lb(`Warning: some data associated with the ${t} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${Jb(i)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${t} scale to "${Jb(i)}".`):n.some(Qg)&&lb(`Warning: some data associated with the ${t} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${Jb(i)}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${t} scale to "${Jb(i)}".`)}switch(r.type=i,i){case"diverging":case"diverging-sqrt":case"diverging-pow":case"diverging-log":case"diverging-symlog":case"cyclical":case"sequential":case"linear":case"sqrt":case"threshold":case"quantile":case"pow":case"log":case"symlog":r=ew(e,r,Ng);break;case"identity":switch(ob.get(t)){case Xg:r=ew(e,r,Ng);break;case ib:r=ew(e,r,nw)}break;case"utc":case"time":r=ew(e,r,Yg)}switch(i){case"diverging":return function(t,e,r){return Nb(t,n.scaleDiverging(),zb,e,r)}(t,e,r);case"diverging-sqrt":return function(t,e,n){return Wb(t,e,{...n,exponent:.5})}(t,e,r);case"diverging-pow":return Wb(t,e,r);case"diverging-log":return function(t,e,{base:r=10,pivot:i=1,domain:o=$b(e,i<0?Dg:Mg),...a}){return Nb(t,n.scaleDivergingLog().base(r=+r),Fb,e,{domain:o,pivot:i,...a})}(t,e,r);case"diverging-symlog":return Yb(t,e,r);case"categorical":case"ordinal":case Gb:return qb(t,e,r);case"cyclical":case"sequential":case"linear":return function(t,e,r){return Mb(t,n.scaleLinear(),e,r)}(t,e,r);case"sqrt":return function(t,e,n){return Db(t,e,{...n,exponent:.5})}(t,e,r);case"threshold":return Pb(t,0,r);case"quantile":return function(t,e,{range:r,quantiles:i=(void 0===r?5:(r=[...r]).length),n:o=i,scheme:a="rdylbu",domain:u=Rb(e),unknown:s,interpolate:c,reverse:l}){return void 0===r&&(r=void 0!==c?n.quantize(c,o):ob.get(t)===tb?gb(a,o):void 0),u.length>0&&(u=n.scaleQuantile(u,void 0===r?{length:o}:r).quantiles()),Pb(t,0,{domain:u,range:r,reverse:l,unknown:s})}(t,e,r);case"quantize":return function(t,e,{range:r,n:i=(void 0===r?5:(r=[...r]).length),scheme:o="rdylbu",domain:a=Eb(t,e),unknown:u,interpolate:s,reverse:c}){const[l,f]=n.extent(a);let h;return void 0===r?(h=n.ticks(l,f,i),h[0]<=l&&h.splice(0,1),h[h.length-1]>=f&&h.pop(),i=h.length+1,r=void 0!==s?n.quantize(s,i):ob.get(t)===tb?gb(o,i):void 0):(h=n.quantize(n.interpolateNumber(l,f),i+1).slice(1,-1),l instanceof Date&&(h=h.map((t=>new Date(t))))),Jg(Fg(a))<0&&h.reverse(),Pb(t,0,{domain:h,range:r,reverse:c,unknown:u})}(t,e,r);case"pow":return Db(t,e,r);case"log":return function(t,e,{base:r=10,domain:i=Ab(e),...o}){return Mb(t,n.scaleLog().base(r),e,{...o,domain:i})}(t,e,r);case"symlog":return function(t,e,{constant:r=1,...i}){return Mb(t,n.scaleSymlog().constant(r),e,i)}(t,e,r);case"utc":return function(t,e,r){return Bb(t,n.scaleUtc(),e,r)}(t,e,r);case"time":return function(t,e,r){return Bb(t,n.scaleTime(),e,r)}(t,e,r);case"point":return function(t,e,{align:r=.5,padding:i=.5,...o}){return Vb(n.scalePoint().align(r).padding(i),e,o,t)}(t,e,r);case"band":return function(t,e,{align:r=.5,padding:i=.1,paddingInner:o=i,paddingOuter:a=("fx"===t||"fy"===t?0:i),...u}){return Vb(n.scaleBand().align(r).paddingInner(o).paddingOuter(a),e,u,t)}(t,e,r);case"identity":return ob.get(t)===Xg?{type:"identity",scale:n.scaleIdentity()}:{type:"identity"};case void 0:return;default:throw new Error(`unknown scale type: ${i}`)}}(t,void 0===r?void 0:[{hint:r}],{...e})}function Jb(t){return"symbol"==typeof t?t.description:t}const Xb={toString:()=>"projection"};function tw(t){switch(t){case Xg:return"point";case tb:return Gb;default:return"ordinal"}}function ew(t,{domain:e,...n},r){for(const e of t)void 0!==e.value&&(e.value=r(e.value));return{domain:void 0===e?e:r(e),...n}}function nw(t){return Hg(t,cb)}function rw({scale:t,type:e,domain:n,range:r,interpolate:i,interval:o,transform:a,percent:u,pivot:s}){if("identity"===e)return{type:"identity",apply:t=>t,invert:t=>t};const c=t.unknown?t.unknown():void 0;return{type:e,domain:Bg(n),...void 0!==r&&{range:Bg(r)},...void 0!==a&&{transform:a},...u&&{percent:u},...void 0!==c&&{unknown:c},...void 0!==o&&{interval:o},...void 0!==i&&{interpolate:i},...t.clamp&&{clamp:t.clamp()},...void 0!==s&&{pivot:s,symmetric:!1},...t.base&&{base:t.base()},...t.exponent&&{exponent:t.exponent()},...t.constant&&{constant:t.constant()},...t.align&&{align:t.align(),round:t.round()},...t.padding&&(t.paddingInner?{paddingInner:t.paddingInner(),paddingOuter:t.paddingOuter()}:{padding:t.padding()}),...t.bandwidth&&{bandwidth:t.bandwidth(),step:t.step()},apply:e=>t(e),...t.invert&&{invert:e=>t.invert(e)}}}function iw(t){try{var e=Object.keys(t)[0];return function(t={}){let e;for(const n in t)if(ob.has(n)&&Gg(t[n])){if(void 0!==e)throw new Error("ambiguous scale definition; multiple scales found");e=rw(Qb(n,t[n]))}if(void 0===e)throw new Error("invalid scale definition; no scale found");return e}((n={},r=e,i=Object.assign(Object.assign({},t[e]),{clamp:!0}),(r=d(r))in n?Object.defineProperty(n,r,{value:i,enumerable:!0,configurable:!0,writable:!0}):n[r]=i,n))}catch(t){return null}var n,r,i}function ow(t,e,n,r){Object.entries(function(t,e){var n={};return e.hasOwnProperty("opacity")?(n.fill=function(){return e.opacity.baseColor||_p},n["fill-opacity"]=function(e){return null==t?void 0:t.apply(e)}):n.fill=function(e){return"string"==typeof e&&(null==e?void 0:e.startsWith("#"))?e:null==t?void 0:t.apply(e)},n}(e,n)).forEach((function(e){var n=c(e,2),i=n[0],o=n[1];return t.style(i,(function(t){return o(r?t[r]:t)}))}))}var aw=function(){function t(e){a(this,t),this.calendar=e}return s(t,[{key:"populate",value:function(){var t=this.calendar,n=t.options.options,r=n.scale,i=n.subDomain,o=iw(r);t.calendarPainter.root.selectAll(".ch-domain").selectAll("svg").selectAll("g").data((function(e){return t.domainCollection.get(e)||[]})).call((function(t){ow(t.select("rect"),o,r,"v")})).call((function(n){n.select("text").attr("style",(function(t){var n=e.hcl(null==o?void 0:o.apply(t.v)).l>60?"#000":"#fff",r=i.color||(t.v?n:null);return Hm(r)&&(r=r(t.t,t.v,null==o?void 0:o.apply(t.v))),r?"fill: ".concat(r,";"):null})).text((function(e,n,r){return t.dateHelper.format(e.t,i.label,e.v,r[n])}))})).call((function(){t.eventEmitter.emit("fill")}))}}]),t}();function uw(t,e){return t===e||t!=t&&e!=e}function sw(t,e){for(var n=t.length;n--;)if(uw(t[n][0],e))return n;return-1}var cw=Array.prototype.splice;function lw(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e-1},lw.prototype.set=function(t,e){var n=this.__data__,r=sw(n,t);return r<0?(++this.size,n.push([t,e])):n[r][1]=e,this};var fw=Mm["__core-js_shared__"],hw=function(){var t=/[^.]+$/.exec(fw&&fw.keys&&fw.keys.IE_PROTO||"");return t?"Symbol(src)_1."+t:""}();var dw=Function.prototype.toString;function pw(t){if(null!=t){try{return dw.call(t)}catch(t){}try{return t+""}catch(t){}}return""}var vw=/^\[object .+?Constructor\]$/,yw=Function.prototype,mw=Object.prototype,gw=yw.toString,bw=mw.hasOwnProperty,ww=RegExp("^"+gw.call(bw).replace(/[\\^$.*+?()[\]{}|]/g,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");function xw(t){return!(!Nm(t)||(e=t,hw&&hw in e))&&(Hm(t)?ww:vw).test(pw(t));var e}function Ow(t,e){var n=function(t,e){return null==t?void 0:t[e]}(t,e);return xw(n)?n:void 0}var kw=Ow(Mm,"Map"),Sw=Ow(Object,"create");var jw=Object.prototype.hasOwnProperty;var _w=Object.prototype.hasOwnProperty;function Mw(t){var e=-1,n=null==t?0:t.length;for(this.clear();++e-1&&t%1==0&&t<=rx}function ox(t){return null!=t&&ix(t.length)&&!Hm(t)}var ax="object"==typeof exports&&exports&&!exports.nodeType&&exports,ux=ax&&"object"==typeof module&&module&&!module.nodeType&&module,sx=ux&&ux.exports===ax?Mm.Buffer:void 0,cx=(sx?sx.isBuffer:void 0)||function(){return!1},lx="[object Object]",fx=Function.prototype,hx=Object.prototype,dx=fx.toString,px=hx.hasOwnProperty,vx=dx.call(Object);var yx={};yx["[object Float32Array]"]=yx["[object Float64Array]"]=yx["[object Int8Array]"]=yx["[object Int16Array]"]=yx["[object Int32Array]"]=yx["[object Uint8Array]"]=yx["[object Uint8ClampedArray]"]=yx["[object Uint16Array]"]=yx["[object Uint32Array]"]=!0,yx["[object Arguments]"]=yx["[object Array]"]=yx["[object ArrayBuffer]"]=yx["[object Boolean]"]=yx["[object DataView]"]=yx["[object Date]"]=yx["[object Error]"]=yx["[object Function]"]=yx["[object Map]"]=yx["[object Number]"]=yx["[object Object]"]=yx["[object RegExp]"]=yx["[object Set]"]=yx["[object String]"]=yx["[object WeakMap]"]=!1;var mx,gx="object"==typeof exports&&exports&&!exports.nodeType&&exports,bx=gx&&"object"==typeof module&&module&&!module.nodeType&&module,wx=bx&&bx.exports===gx&&jm.process,xx=function(){try{var t=bx&&bx.require&&bx.require("util").types;return t||wx&&wx.binding&&wx.binding("util")}catch(t){}}(),Ox=xx&&xx.isTypedArray,kx=Ox?(mx=Ox,function(t){return mx(t)}):function(t){return Zw(t)&&ix(t.length)&&!!yx[Im(t)]};function Sx(t,e){if(("constructor"!==e||"function"!=typeof t[e])&&"__proto__"!=e)return t[e]}var jx=Object.prototype.hasOwnProperty;function _x(t,e,n){var r=t[e];jx.call(t,e)&&uw(r,n)&&(void 0!==n||e in t)||Tw(t,e,n)}var Mx=9007199254740991,Dx=/^(?:0|[1-9]\d*)$/;function Px(t,e){var n=typeof t;return!!(e=null==e?Mx:e)&&("number"==n||"symbol"!=n&&Dx.test(t))&&t>-1&&t%1==0&&t0){if(++e>=800)return arguments[0]}else e=0;return t.apply(void 0,arguments)}}(zx),Bx=Hx;function Gx(t,e){return Bx(function(t,e,n){return e=Wx(void 0===e?t.length-1:e,0),function(){for(var r=arguments,i=-1,o=Wx(r.length-e,0),a=Array(o);++i1?e[r-1]:void 0,o=r>2?e[2]:void 0;for(i=Ux.length>3&&"function"==typeof i?(r--,i):void 0,o&&function(t,e,n){if(!Nm(n))return!1;var r=typeof e;return!!("number"==r?ox(n)&&Px(e,n.length):"string"==r&&e in n)&&uw(n[e],t)}(e[0],e[1],o)&&(i=r<3?void 0:i,r=1),t=Object(t);++nu))return!1;var c=o.get(t),l=o.get(e);if(c&&l)return c==e&&l==t;var f=-1,h=!0,d=n&Jx?new Kx:void 0;for(o.set(t,e),o.set(e,t);++f0&&void 0!==arguments[0]?arguments[0]:xk;a(this,t),this.preProcessors=e,this.options={itemSelector:"#cal-heatmap",range:12,domain:{type:"hour",gutter:4,padding:[0,0,0,0],dynamicDimension:!0,sort:"asc",label:{text:void 0,position:"bottom",textAlign:"middle",offset:{x:0,y:0},rotate:null,width:100,height:25}},subDomain:{type:"minute",width:10,height:10,gutter:2,radius:0,label:null,color:void 0,sort:"asc"},date:{start:new Date,min:void 0,max:void 0,highlight:[],locale:"en",timezone:void 0},verticalOrientation:!1,data:{source:"",type:"json",requestInit:{},x:"",y:"",groupY:"sum",defaultValue:null},scale:void 0,animationDuration:200,theme:"light",x:{domainHorizontalLabelWidth:0,domainVerticalLabelHeight:0}}}return s(t,[{key:"set",value:function(t,e){return!(!yk(this.options,t)||ZO(mk(this.options,t),e))&&(gk(this.options,t,yk(this.preProcessors,t)?mk(this.preProcessors,t)(e):e),!0)}},{key:"init",value:function(t){var e=this;this.options=Object.assign({},Vx(this.options,t,(function(t,e){return Array.isArray(e)?e:void 0})));var n=this.options;Object.keys(this.preProcessors).forEach((function(t){gk(n,t,mk(e.preProcessors,t)(mk(n,t)))})),void 0===n.scale&&this.initScale(),n.x.domainVerticalLabelHeight=n.domain.label.height,"top"===n.domain.label.position||"bottom"===n.domain.label.position?n.x.domainHorizontalLabelWidth=0:(n.x.domainVerticalLabelHeight=0,n.x.domainHorizontalLabelWidth=n.domain.label.width),null!==n.domain.label.text&&""!==n.domain.label.text||(n.x.domainVerticalLabelHeight=0,n.x.domainHorizontalLabelWidth=0)}},{key:"initScale",value:function(){this.options.scale={color:{scheme:"YlOrBr",type:"quantize",domain:Mp}}}}]),t}(),kk=Yt,Sk=P,jk=m.RegExp,_k=Sk((function(){var t=jk("a","y");return t.lastIndex=2,null!==t.exec("abcd")})),Mk=_k||Sk((function(){return!jk("a","y").sticky})),Dk=_k||Sk((function(){var t=jk("^r","gy");return t.lastIndex=2,null!==t.exec("str")})),Pk={BROKEN_CARET:Dk,MISSED_STICKY:Mk,UNSUPPORTED_Y:_k},$k=P,Ek=m.RegExp,Lk=$k((function(){var t=Ek(".","s");return!(t.dotAll&&t.test("\n")&&"s"===t.flags)})),Tk=P,Ck=m.RegExp,Ak=Tk((function(){var t=Ck("(?b)","g");return"b"!==t.exec("b").groups.a||"bc"!=="b".replace(t,"$c")})),Rk=Ht,Ik=A,Nk=cf,Wk=function(){var t=kk(this),e="";return t.hasIndices&&(e+="d"),t.global&&(e+="g"),t.ignoreCase&&(e+="i"),t.multiline&&(e+="m"),t.dotAll&&(e+="s"),t.unicode&&(e+="u"),t.unicodeSets&&(e+="v"),t.sticky&&(e+="y"),e},Yk=Pk,zk=zc,Fk=gn.get,Hk=Lk,Bk=Ak,Gk=D("native-string-replace",String.prototype.replace),Uk=RegExp.prototype.exec,qk=Uk,Vk=Ik("".charAt),Kk=Ik("".indexOf),Zk=Ik("".replace),Qk=Ik("".slice),Jk=(wk=/b*/g,Rk(Uk,bk=/a/,"a"),Rk(Uk,wk,"a"),0!==bk.lastIndex||0!==wk.lastIndex),Xk=Yk.BROKEN_CARET,tS=void 0!==/()??/.exec("")[1];(Jk||tS||Xk||Hk||Bk)&&(qk=function(t){var e,n,r,i,o,a,u,s=this,c=Fk(s),l=Nk(t),f=c.raw;if(f)return f.lastIndex=s.lastIndex,e=Rk(qk,f,l),s.lastIndex=f.lastIndex,e;var h=c.groups,d=Xk&&s.sticky,p=Rk(Wk,s),v=s.source,y=0,m=l;if(d&&(p=Zk(p,"y",""),-1===Kk(p,"g")&&(p+="g"),m=Qk(l,s.lastIndex),s.lastIndex>0&&(!s.multiline||s.multiline&&"\n"!==Vk(l,s.lastIndex-1))&&(v="(?: "+v+")",m=" "+m,y++),n=new RegExp("^(?:"+v+")",p)),tS&&(n=new RegExp("^"+v+"$(?!\\s)",p)),Jk&&(r=s.lastIndex),i=Rk(Uk,d?n:s,m),d?i?(i.input=Qk(i.input,y),i[0]=Qk(i[0],y),i.index=s.lastIndex,s.lastIndex+=i[0].length):s.lastIndex=0:Jk&&i&&(s.lastIndex=s.global?i.index+i[0].length:r),tS&&i&&i.length>1&&Rk(Gk,i[0],n,(function(){for(o=1;o]*>)/g,wS=/\$([$&'`]|\d{1,2})/g,xS=Ht,OS=Yt,kS=St,SS=Gn,jS=eS,_S=TypeError,MS=_o,DS=Ht,PS=A,$S=function(t,e,n,r){var i=sS(t),o=!uS((function(){var e={};return e[i]=function(){return 7},7!==""[t](e)})),a=o&&!uS((function(){var e=!1,n=/a/;return"split"===t&&((n={}).constructor={},n.constructor[lS]=function(){return n},n.flags="",n[i]=/./[i]),n.exec=function(){return e=!0,null},n[i](""),!e}));if(!o||!a||n){var u=iS(/./[i]),s=e(i,""[t],(function(t,e,n,r,i){var a=iS(t),s=e.exec;return s===aS||s===fS.exec?o&&!i?{done:!0,value:u(e,n,r)}:{done:!0,value:a(n,e,r)}:{done:!1}}));oS(String.prototype,t,s[0]),oS(fS,i,s[1])}r&&cS(fS[i],"sham",!0)},ES=P,LS=Yt,TS=St,CS=R,AS=Mr,RS=Cr,IS=cf,NS=W,WS=function(t,e,n){return e+(n?hS(t,e).length:1)},YS=ue,zS=function(t,e,n,r,i,o){var a=n+t.length,u=r.length,s=wS;return void 0!==i&&(i=pS(i),s=bS),mS(o,s,(function(o,s){var c;switch(yS(s,0)){case"$":return"$";case"&":return t;case"`":return gS(e,0,n);case"'":return gS(e,a);case"<":c=i[gS(s,1,-1)];break;default:var l=+s;if(0===l)return o;if(l>u){var f=vS(l/10);return 0===f?o:f<=u?void 0===r[f-1]?yS(s,1):r[f-1]+yS(s,1):o}c=r[l-1]}return void 0===c?"":c}))},FS=function(t,e){var n=t.exec;if(kS(n)){var r=xS(n,t,e);return null!==r&&OS(r),r}if("RegExp"===SS(t))return xS(jS,t,e);throw new _S("RegExp#exec called on incompatible receiver")},HS=gt("replace"),BS=Math.max,GS=Math.min,US=PS([].concat),qS=PS([].push),VS=PS("".indexOf),KS=PS("".slice),ZS="$0"==="a".replace(/./,"$0"),QS=!!/./[HS]&&""===/./[HS]("a","$0"),JS=!ES((function(){var t=/./;return t.exec=function(){var t=[];return t.groups={a:"7"},t},"7"!=="".replace(t,"$")}));$S("replace",(function(t,e,n){var r=QS?"$":"$0";return[function(t,n){var r=NS(this),i=CS(t)?void 0:YS(t,HS);return i?DS(i,t,r,n):DS(e,IS(r),t,n)},function(t,i){var o=LS(this),a=IS(t);if("string"==typeof i&&-1===VS(i,r)&&-1===VS(i,"$<")){var u=n(e,o,a,i);if(u.done)return u.value}var s=TS(i);s||(i=IS(i));var c,l=o.global;l&&(c=o.unicode,o.lastIndex=0);for(var f,h=[];null!==(f=FS(o,a))&&(qS(h,f),l);){""===IS(f[0])&&(o.lastIndex=WS(a,RS(o.lastIndex),c))}for(var d,p="",v=0,y=0;y=v&&(p+=KS(a,v,b)+m,v=b+g.length)}return p+KS(a,v)}]}),!JS||!ZS||QS);var XS=function(){function t(e){a(this,t),nS.add(this),this.calendar=e}return s(t,[{key:"getDatas",value:function(t,e,n){return yh(this,void 0,void 0,i().mark((function r(){var o;return i().wrap((function(r){for(;;)switch(r.prev=r.next){case 0:if(!("string"==typeof t&&t.length>0)){r.next=2;break}return r.abrupt("return",mh(this,nS,"m",rS).call(this,t,e,n));case 2:return o=[],Array.isArray(t)&&(o=t),r.abrupt("return",new Promise((function(t){t(o)})));case 5:case"end":return r.stop()}}),r,this)})))}},{key:"parseURI",value:function(t,e,n){var r=this,i=t.replace(/\{\{start=(.*?)\}\}/g,(function(t,n){return r.calendar.dateHelper.date(e).format(n)}));return i=i.replace(/\{\{end=(.*?)\}\}/g,(function(t,e){return r.calendar.dateHelper.date(n).format(e)}))}}]),t}();nS=new WeakSet,rS=function(t,e,n){var i=this.calendar.options.options.data,o=i.type,a=i.requestInit,u=this.parseURI(t,e,n);switch(o){case"json":return r.json(u,a);case"csv":return r.csv(u,a);case"tsv":return r.dsv("\t",u,a);case"txt":return r.text(u,a);default:return new Promise((function(t){t([])}))}};var tj=_t,ej=We.EXISTS,nj=A,rj=zi,ij=Function.prototype,oj=nj(ij.toString),aj=/function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/,uj=nj(aj.exec);tj&&!ej&&rj(ij,"name",{configurable:!0,get:function(){try{return uj(aj,oj(this))[1]}catch(t){return""}}});var sj={exports:{}};!function(t,e){t.exports=function(){var t=1e3,e=6e4,n=36e5,r="millisecond",i="second",o="minute",a="hour",u="day",s="week",c="month",l="quarter",f="year",h="date",d="Invalid Date",p=/^(\d{4})[-/]?(\d{1,2})?[-/]?(\d{0,2})[Tt\s]*(\d{1,2})?:?(\d{1,2})?:?(\d{1,2})?[.:]?(\d+)?$/,v=/\[([^\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,y={name:"en",weekdays:"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday".split("_"),months:"January_February_March_April_May_June_July_August_September_October_November_December".split("_"),ordinal:function(t){var e=["th","st","nd","rd"],n=t%100;return"["+t+(e[(n-20)%10]||e[n]||e[0])+"]"}},m=function(t,e,n){var r=String(t);return!r||r.length>=e?t:""+Array(e+1-r.length).join(n)+t},g={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?"+":"-")+m(r,2,"0")+":"+m(i,2,"0")},m:function t(e,n){if(e.date()1)return t(a[0])}else{var u=e.name;w[u]=e,i=u}return!r&&i&&(b=i),i||!r&&b},S=function(t,e){if(O(t))return t.clone();var n="object"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},j=g;j.l=k,j.i=O,j.w=function(t,e){return S(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function y(t){this.$L=k(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[x]=!0}var m=y.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(j.u(e))return new Date;if(e instanceof Date)return new Date(e);if("string"==typeof e&&!/Z$/i.test(e)){var r=e.match(p);if(r){var i=r[2]-1||0,o=(r[7]||"0").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,o)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,o)}}return new Date(e)}(t),this.init()},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},m.$utils=function(){return j},m.isValid=function(){return!(this.$d.toString()===d)},m.isSame=function(t,e){var n=S(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return S(t)25){var o=i(this).startOf(r).add(1,r).date(e),a=i(this).endOf(n);if(o.isBefore(a))return 1}var u=i(this).startOf(r).date(e).startOf(n).subtract(1,"millisecond"),s=this.diff(u,n,!0);return s<0?i(this).startOf("week").week():Math.ceil(s)},o.weeks=function(t){return void 0===t&&(t=null),this.week(t)}})}(lj);var fj=v(lj.exports),hj={exports:{}};!function(t,e){t.exports=function(t,e,n){e.prototype.dayOfYear=function(t){var e=Math.round((n(this).startOf("day")-n(this).startOf("year"))/864e5)+1;return null==t?e:this.add(t-e,"day")}}}(hj);var dj=v(hj.exports),pj={exports:{}};!function(t,e){t.exports=function(t,e){e.prototype.weekday=function(t){var e=this.$locale().weekStart||0,n=this.$W,r=(n0&&(e=e[0]),n=(e=e.filter((function(t){return t})))[0];for(var r=1;r4&&(a+=7),o.add(a,n));return u.diff(s,"week")+1},o.isoWeekday=function(t){return this.$utils().u(t)?this.day()||7:this.day(this.day()%7?t:t-7)};var a=o.startOf;o.startOf=function(t,e){var n=this.$utils(),r=!!n.u(e)||e;return"isoweek"===n.p(t)?r?this.date(this.date()-(this.isoWeekday()-1)).startOf("day"):this.date(this.date()-1-(this.isoWeekday()-1)+7).endOf("day"):a.bind(this)(t,e)}})}(wj);var xj=v(wj.exports),Oj={exports:{}};!function(t,e){t.exports=function(t,e){e.prototype.isLeapYear=function(){return this.$y%4==0&&this.$y%100!=0||this.$y%400==0}}}(Oj);var kj=v(Oj.exports),Sj={exports:{}};!function(t,e){t.exports=function(t,e){var n=e.prototype,r=n.format;n.format=function(t){var e=this,n=this.$locale();if(!this.isValid())return r.bind(this)(t);var i=this.$utils(),o=(t||"YYYY-MM-DDTHH:mm:ssZ").replace(/\[([^\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g,(function(t){switch(t){case"Q":return Math.ceil((e.$M+1)/3);case"Do":return n.ordinal(e.$D);case"gggg":return e.weekYear();case"GGGG":return e.isoWeekYear();case"wo":return n.ordinal(e.week(),"W");case"w":case"ww":return i.s(e.week(),"w"===t?1:2,"0");case"W":case"WW":return i.s(e.isoWeek(),"W"===t?1:2,"0");case"k":case"kk":return i.s(String(0===e.$H?24:e.$H),"k"===t?1:2,"0");case"X":return Math.floor(e.$d.getTime()/1e3);case"x":return e.$d.getTime();case"z":return"["+e.offsetName()+"]";case"zzz":return"["+e.offsetName("long")+"]";default:return t}}));return r.bind(this)(o)}}}(Sj);var jj=v(Sj.exports),_j={exports:{}};!function(t,e){var n,r,i;t.exports=(n="minute",r=/[+-]\d\d(?::?\d\d)?/g,i=/([+-]|\d\d)/g,function(t,e,o){var a=e.prototype;o.utc=function(t){return new e({date:t,utc:!0,args:arguments})},a.utc=function(t){var e=o(this.toDate(),{locale:this.$L,utc:!0});return t?e.add(this.utcOffset(),n):e},a.local=function(){return o(this.toDate(),{locale:this.$L,utc:!1})};var u=a.parse;a.parse=function(t){t.utc&&(this.$u=!0),this.$utils().u(t.$offset)||(this.$offset=t.$offset),u.call(this,t)};var s=a.init;a.init=function(){if(this.$u){var t=this.$d;this.$y=t.getUTCFullYear(),this.$M=t.getUTCMonth(),this.$D=t.getUTCDate(),this.$W=t.getUTCDay(),this.$H=t.getUTCHours(),this.$m=t.getUTCMinutes(),this.$s=t.getUTCSeconds(),this.$ms=t.getUTCMilliseconds()}else s.call(this)};var c=a.utcOffset;a.utcOffset=function(t,e){var o=this.$utils().u;if(o(t))return this.$u?0:o(this.$offset)?c.call(this):this.$offset;if("string"==typeof t&&(t=function(t){void 0===t&&(t="");var e=t.match(r);if(!e)return null;var n=(""+e[0]).match(i)||["-",0,0],o=n[0],a=60*+n[1]+ +n[2];return 0===a?0:"+"===o?a:-a}(t),null===t))return this;var a=Math.abs(t)<=16?60*t:t,u=this;if(e)return u.$offset=a,u.$u=0===t,u;if(0!==t){var s=this.$u?this.toDate().getTimezoneOffset():-1*this.utcOffset();(u=this.local().add(a+s,n)).$offset=a,u.$x.$localOffset=s}else u=this.utc();return u};var l=a.format;a.format=function(t){var e=t||(this.$u?"YYYY-MM-DDTHH:mm:ss[Z]":"");return l.call(this,e)},a.valueOf=function(){var t=this.$utils().u(this.$offset)?0:this.$offset+(this.$x.$localOffset||this.$d.getTimezoneOffset());return this.$d.valueOf()-6e4*t},a.isUTC=function(){return!!this.$u},a.toISOString=function(){return this.toDate().toISOString()},a.toString=function(){return this.toDate().toUTCString()};var f=a.toDate;a.toDate=function(t){return"s"===t&&this.$offset?o(this.format("YYYY-MM-DD HH:mm:ss:SSS")).toDate():f.call(this)};var h=a.diff;a.diff=function(t,e,n){if(t&&this.$u===t.$u)return h.call(this,t,e,n);var r=this.local(),i=o(t).local();return h.call(r,i,e,n)}})}(_j);var Mj=v(_j.exports),Dj={exports:{}};!function(t,e){var n,r;t.exports=(n={year:0,month:1,day:2,hour:3,minute:4,second:5},r={},function(t,e,i){var o,a=function(t,e,n){void 0===n&&(n={});var i=new Date(t),o=function(t,e){void 0===e&&(e={});var n=e.timeZoneName||"short",i=t+"|"+n,o=r[i];return o||(o=new Intl.DateTimeFormat("en-US",{hour12:!1,timeZone:t,year:"numeric",month:"2-digit",day:"2-digit",hour:"2-digit",minute:"2-digit",second:"2-digit",timeZoneName:n}),r[i]=o),o}(e,n);return o.formatToParts(i)},u=function(t,e){for(var r=a(t,e),o=[],u=0;u=0&&(o[f]=parseInt(l,10))}var h=o[3],d=24===h?0:h,p=o[0]+"-"+o[1]+"-"+o[2]+" "+d+":"+o[4]+":"+o[5]+":000",v=+t;return(i.utc(p).valueOf()-(v-=v%1e3))/6e4},s=e.prototype;s.tz=function(t,e){void 0===t&&(t=o);var n=this.utcOffset(),r=this.toDate(),a=r.toLocaleString("en-US",{timeZone:t}),u=Math.round((r-new Date(a))/1e3/60),s=i(a,{locale:this.$L}).$set("millisecond",this.$ms).utcOffset(15*-Math.round(r.getTimezoneOffset()/15)-u,!0);if(e){var c=s.utcOffset();s=s.add(n-c,"minute")}return s.$x.$timezone=t,s},s.offsetName=function(t){var e=this.$x.$timezone||i.tz.guess(),n=a(this.valueOf(),e,{timeZoneName:t}).find((function(t){return"timezonename"===t.type.toLowerCase()}));return n&&n.value};var c=s.startOf;s.startOf=function(t,e){if(!this.$x||!this.$x.$timezone)return c.call(this,t,e);var n=i(this.format("YYYY-MM-DD HH:mm:ss:SSS"),{locale:this.$L});return c.call(n,t,e).tz(this.$x.$timezone,!0)},i.tz=function(t,e,n){var r=n&&e,a=n||e||o,s=u(+i(),a);if("string"!=typeof t)return i(t).tz(a);var c=function(t,e,n){var r=t-60*e*1e3,i=u(r,n);if(e===i)return[r,e];var o=u(r-=60*(i-e)*1e3,n);return i===o?[r,i]:[t-60*Math.min(i,o)*1e3,Math.max(i,o)]}(i.utc(t,r).valueOf(),s,a),l=c[0],f=c[1],h=i(l).utcOffset(f);return h.$x.$timezone=a,h},i.tz.guess=function(){return Intl.DateTimeFormat().resolvedOptions().timeZone},i.tz.setDefault=function(t){o=t}})}(Dj);var Pj=v(Dj.exports),$j={exports:{}};!function(t,e){t.exports=function(t,e,n){var r=e.prototype,i=function(t){return t&&(t.indexOf?t:t.s)},o=function(t,e,n,r,o){var a=t.name?t:t.$locale(),u=i(a[e]),s=i(a[n]),c=u||s.map((function(t){return t.slice(0,r)}));if(!o)return c;var l=a.weekStart;return c.map((function(t,e){return c[(e+(l||0))%7]}))},a=function(){return n.Ls[n.locale()]},u=function(t,e){return t.formats[e]||function(t){return t.replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(t,e,n){return e||n.slice(1)}))}(t.formats[e.toUpperCase()])},s=function(){var t=this;return{months:function(e){return e?e.format("MMMM"):o(t,"months")},monthsShort:function(e){return e?e.format("MMM"):o(t,"monthsShort","months",3)},firstDayOfWeek:function(){return t.$locale().weekStart||0},weekdays:function(e){return e?e.format("dddd"):o(t,"weekdays")},weekdaysMin:function(e){return e?e.format("dd"):o(t,"weekdaysMin","weekdays",2)},weekdaysShort:function(e){return e?e.format("ddd"):o(t,"weekdaysShort","weekdays",3)},longDateFormat:function(e){return u(t.$locale(),e)},meridiem:this.$locale().meridiem,ordinal:this.$locale().ordinal}};r.localeData=function(){return s.bind(this)()},n.localeData=function(){var t=a();return{firstDayOfWeek:function(){return t.weekStart||0},weekdays:function(){return n.weekdays()},weekdaysShort:function(){return n.weekdaysShort()},weekdaysMin:function(){return n.weekdaysMin()},months:function(){return n.months()},monthsShort:function(){return n.monthsShort()},longDateFormat:function(e){return u(t,e)},meridiem:t.meridiem,ordinal:t.ordinal}},n.months=function(){return o(a(),"months")},n.monthsShort=function(){return o(a(),"monthsShort","months",3)},n.weekdays=function(t){return o(a(),"weekdays",null,null,t)},n.weekdaysShort=function(t){return o(a(),"weekdaysShort","weekdays",3,t)},n.weekdaysMin=function(t){return o(a(),"weekdaysMin","weekdays",2,t)}}}($j);var Ej=v($j.exports),Lj={exports:{}};!function(t,e){var n;t.exports=(n={LTS:"h:mm:ss A",LT:"h:mm A",L:"MM/DD/YYYY",LL:"MMMM D, YYYY",LLL:"MMMM D, YYYY h:mm A",LLLL:"dddd, MMMM D, YYYY h:mm A"},function(t,e,r){var i=e.prototype,o=i.format;r.en.formats=n,i.format=function(t){void 0===t&&(t="YYYY-MM-DDTHH:mm:ssZ");var e=this.$locale().formats,r=function(t,e){return t.replace(/(\[[^\]]+])|(LTS?|l{1,4}|L{1,4})/g,(function(t,r,i){var o=i&&i.toUpperCase();return r||e[i]||n[i]||e[o].replace(/(\[[^\]]+])|(MMMM|MM|DD|dddd)/g,(function(t,e,n){return e||n.slice(1)}))}))}(t,void 0===e?{}:e);return o.call(this,r)}})}(Lj);var Tj=v(Lj.exports),Cj={exports:{}};!function(t,e){t.exports=function(t,e,n){n.updateLocale=function(t,e){var r=n.Ls[t];if(r)return(e?Object.keys(e):[]).forEach((function(t){r[t]=e[t]})),r}}}(Cj);var Aj=v(Cj.exports);cj.extend(fj),cj.extend(bj),cj.extend(xj),cj.extend(kj),cj.extend(dj),cj.extend(vj),cj.extend(mj),cj.extend(jj),cj.extend(Mj),cj.extend(Pj),cj.extend(Ej),cj.extend(Tj),cj.extend(Aj);var Rj="en",Ij=function(){function t(){var e;a(this,t),this.locale=Rj,this.timezone=cj.tz.guess(),"object"===("undefined"==typeof window?"undefined":o(window))&&((e=window).dayjs||(e.dayjs=cj))}return s(t,[{key:"setup",value:function(t){var e=t.options;return yh(this,void 0,void 0,i().mark((function t(){var n,r;return i().wrap((function(t){for(;;)switch(t.prev=t.next){case 0:if(this.timezone=e.date.timezone||cj.tz.guess(),"string"!=typeof(n=e.date.locale)||n===Rj){t.next=17;break}if("object"!==("undefined"==typeof window?"undefined":o(window))){t.next=12;break}if(t.t0=window["dayjs_locale_".concat(n)],t.t0){t.next=9;break}return t.next=8,this.loadBrowserLocale(n);case 8:t.t0=t.sent;case 9:r=t.t0,t.next=15;break;case 12:return t.next=14,this.loadNodeLocale(n);case 14:r=t.sent;case 15:cj.locale(n),this.locale=r;case 17:"object"===o(n)&&(n.hasOwnProperty("name")?(cj.locale(n.name,n),this.locale=n):this.locale=cj.updateLocale(Rj,n));case 18:case"end":return t.stop()}}),t,this)})))}},{key:"extend",value:function(t){return cj.extend(t)}},{key:"getMonthWeekNumber",value:function(t){var e=this.date(t),n=e.startOf("day"),r=e.startOf("month").endOf("week");return n<=r?1:Math.ceil(n.diff(r,"weeks",!0))+1}},{key:"getWeeksCountInMonth",value:function(t){var e=this.date(t);return this.getLastWeekOfMonth(e).diff(this.getFirstWeekOfMonth(e),"week")+1}},{key:"getFirstWeekOfMonth",value:function(t){var e=this.date(t).startOf("month"),n=e.startOf("week");return e.weekday()>4&&(n=n.add(1,"week")),n}},{key:"getLastWeekOfMonth",value:function(t){var e=this.date(t).endOf("month"),n=e.endOf("week");return e.weekday()<4&&(n=n.subtract(1,"week")),n}},{key:"date",value:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:new Date;return cj.isDayjs(t)?t:cj(t).tz(this.timezone).utcOffset(0).locale(this.locale)}},{key:"format",value:function(t,e){if("function"==typeof e){for(var n=arguments.length,r=new Array(n>2?n-2:0),i=2;i3&&void 0!==arguments[3])||arguments[3],o=this.date(e);r="number"==typeof n?o.add(n,t):cj.isDayjs(n)?n:this.date(n),o=o.startOf(t),r=r.startOf(t);var a=cj.min(o,r);r=cj.max(o,r);var u=[];i||(r=r.add(1,"second"));do{u.push(+a),a=a.add(1,t)}while(a1?arguments[1]:void 0)}});var Bj=["json","csv","tsv","txt"];function Gj(t,e){var n=e.domain,r=e.subDomain,i=e.data,o=n.type,a=r.type;if(!t.has(o))throw new Error("'".concat(o,"' is not a valid domain type'"));if(!t.has(a))throw new Error("'".concat(a,"' is not a valid subDomain type'"));if(i.type&&!Bj.includes(i.type))throw new Error("The data type '".concat(i.type,"' is not valid data type"));if(!(t.get(a).allowedDomainType||[]).includes(o))throw new Error("The subDomain.type '".concat(a,"' can not be used together ")+"with the domain type ".concat(o));return!0}Xd("Set",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),fv);var Uj=function(){function t(e){a(this,t),this.calendar=e,this.settings=new Map,this.plugins=new Map,this.pendingPaint=new Set}return s(t,[{key:"add",value:function(t){var e=this;t.forEach((function(t){var n,r,i=c(t,2),o=i[0],a=i[1],u=function(t,e){return"".concat((new t).name).concat((null==e?void 0:e.key)||"")}(o,a);e.plugins.get(u)&&e.settings.get(u)&&ZO(e.settings.get(u).options,a)||(e.settings.set(u,{options:a,dirty:!0}),e.plugins.has(u)||e.plugins.set(u,(n=o,r=e.calendar,new n(r))),e.pendingPaint.add(e.plugins.get(u)))}))}},{key:"setupAll",value:function(){var t=this;this.plugins.forEach((function(e,n){var r=t.settings.get(n);void 0!==r&&r.dirty&&(e.setup(r.options),r.dirty=!1,t.settings.set(n,r))}))}},{key:"paintAll",value:function(){return Array.from(this.pendingPaint.values()).map((function(t){return t.paint()}))}},{key:"destroyAll",value:function(){return this.allPlugins().map((function(t){return t.destroy()}))}},{key:"getFromPosition",value:function(t){return this.allPlugins().filter((function(e){var n;return(null===(n=e.options)||void 0===n?void 0:n.position)===t}))}},{key:"getHeightFromPosition",value:function(t){return this.getFromPosition(t).map((function(t){return t.options.dimensions.height})).reduce((function(t,e){return t+e}),0)}},{key:"getWidthFromPosition",value:function(t){return this.getFromPosition(t).map((function(t){return t.options.dimensions.width})).reduce((function(t,e){return t+e}),0)}},{key:"allPlugins",value:function(){return Array.from(this.plugins.values())}}]),t}(),qj=[function(t){return{name:"minute",allowedDomainType:["day","hour"],rowsCount:function(){return 10},columnsCount:function(){return 6},mapping:function(e,n){return t.intervals("minute",e,t.date(n)).map((function(t,e){return{t:t,x:Math.floor(e/10),y:e%10}}))},extractUnit:function(e){return t.date(e).startOf("minute").valueOf()}}},function(t,e){var n=e.domain;return{name:"hour",allowedDomainType:["month","week","day"],rowsCount:function(){return 6},columnsCount:function(e){switch(n.type){case"week":return 28;case"month":return 4*(n.dynamicDimension?t.date(e).daysInMonth():31);default:return 4}},mapping:function(e,r){return t.intervals("hour",e,t.date(r)).map((function(e){var r=t.date(e),i=r.hour(),o=r.date(),a=Math.floor(i/6);return"month"===n.type&&(a+=4*(o-1)),"week"===n.type&&(a+=4*+r.format("d")),{t:e,x:a,y:Math.floor(i%6)}}))},extractUnit:function(e){return t.date(e).startOf("hour").valueOf()}}},function(t,e){var n=e.domain,r=e.verticalOrientation;return{name:"day",allowedDomainType:["year","month","week"],rowsCount:function(){return"week"===n.type?1:7},columnsCount:function(e){switch(n.type){case"month":return Math.ceil(n.dynamicDimension&&!r?t.getMonthWeekNumber(t.date(e).endOf("month")):6);case"year":return Math.ceil(n.dynamicDimension?t.date(e).endOf("year").dayOfYear()/7:54);default:return 7}},mapping:function(e,r){var i=0,o=-1;return t.intervals("day",e,t.date(r)).map((function(e){var r=t.date(e);switch(n.type){case"month":o=t.getMonthWeekNumber(e)-1;break;case"year":i!==r.week()&&(i=r.week(),o+=1);break;case"week":o=r.weekday()}return{t:e,x:o,y:"week"===n.type?0:r.weekday()}}))},extractUnit:function(e){return t.date(e).startOf("day").valueOf()}}},function(t,e){var n=e.domain,r=e.verticalOrientation;return{name:"xDay",allowedDomainType:["year","month","week"],rowsCount:function(e){switch(n.type){case"month":return Math.ceil(n.dynamicDimension&&!r?t.getMonthWeekNumber(t.date(e).endOf("month")):6);case"year":return Math.ceil(n.dynamicDimension?t.date(e).endOf("year").dayOfYear()/7:54);default:return 7}},columnsCount:function(){return"week"===n.type?1:7},mapping:function(e,r){return t.intervals("day",e,t.date(r)).map((function(e){var r=t.date(e),i=r.endOf("year").week(),o=0;switch(n.type){case"month":o=t.getMonthWeekNumber(e)-1;break;case"year":1===i&&r.week()===i&&(o=r.subtract(1,"week").week()+1),o=r.week()-1;break;case"week":o=r.weekday()}return{t:e,y:o,x:"week"===n.type?0:r.weekday()}}))},extractUnit:function(e){return t.date(e).startOf("day").valueOf()}}},function(t){return{name:"ghDay",allowedDomainType:["month"],rowsCount:function(){return 7},columnsCount:function(e){return t.getWeeksCountInMonth(e)},mapping:function(e,n){var r=t.getFirstWeekOfMonth(e),i=t.getFirstWeekOfMonth(n),o=-1,a=r.weekday();return t.intervals("day",r,i).map((function(e){var n=t.date(e).weekday();return n===a&&(o+=1),{t:e,x:o,y:n}}))},extractUnit:function(e){return t.date(e).startOf("day").valueOf()}}},function(t,e){var n=e.domain;return{name:"week",allowedDomainType:["year","month"],rowsCount:function(){return 1},columnsCount:function(e){switch(n.type){case"year":return n.dynamicDimension?t.date(e).endOf("year").isoWeeksInYear():53;case"month":return n.dynamicDimension?t.getWeeksCountInMonth(e):5;default:return 1}},mapping:function(e,n){var r=t.getFirstWeekOfMonth(e),i=t.getFirstWeekOfMonth(n);return t.intervals("week",r,i).map((function(t,e){return{t:t,x:e,y:0}}))},extractUnit:function(e){return t.date(e).startOf("week").valueOf()}}},function(t){return{name:"month",allowedDomainType:["year"],rowsCount:function(){return 1},columnsCount:function(){return 12},mapping:function(e,n){return t.intervals("month",e,t.date(n)).map((function(e){return{t:e,x:t.date(e).month(),y:0}}))},extractUnit:function(e){return t.date(e).startOf("month").valueOf()}}},function(t){return{name:"year",allowedDomainType:[],rowsCount:function(){return 1},columnsCount:function(){return 1},mapping:function(e,n){return t.intervals("year",e,t.date(n)).map((function(t,e){return{t:t,x:e,y:0}}))},extractUnit:function(e){return t.date(e).startOf("year").valueOf()}}}],Vj=function(){function t(e,n){a(this,t),this.settings=new Map,this.dateHelper=e,this.options=n,this.initiated=!1}return s(t,[{key:"get",value:function(t){return this.settings.get(t)}},{key:"has",value:function(t){return this.settings.has(t)}},{key:"init",value:function(){this.initiated||(this.initiated=!0,this.add(qj))}},{key:"add",value:function(t){var e=this;this.init();var n=[];xh(t).forEach((function(t){var r=t(e.dateHelper,e.options.options);e.settings.set(r.name,r),r.hasOwnProperty("parent")&&n.push(r.name)})),n.forEach((function(t){var n=e.settings.get(e.settings.get(t).parent);n&&e.settings.set(t,Object.assign(Object.assign({},n),e.settings.get(t)))}))}}]),t}(),Kj=function(){function t(){a(this,t),this.options=new Ok,this.dateHelper=new Ij,this.templateCollection=new Vj(this.dateHelper,this.options),this.dataFetcher=new XS(this),this.navigator=new Dp(this),this.populator=new aw(this),this.calendarPainter=new Sm(this),this.eventEmitter=new bh,this.pluginManager=new Uj(this)}return s(t,[{key:"createDomainCollection",value:function(t,e){var n=!(arguments.length>2&&void 0!==arguments[2])||arguments[2];return new zy(this.dateHelper,this.options.options.domain.type,t,e,n)}},{key:"paint",value:function(t,e){return yh(this,void 0,void 0,i().mark((function n(){return i().wrap((function(n){for(;;)switch(n.prev=n.next){case 0:return this.options.init(t),n.next=3,this.dateHelper.setup(this.options);case 3:this.templateCollection.init(),n.prev=4,Gj(this.templateCollection,this.options.options),n.next=11;break;case 8:return n.prev=8,n.t0=n.catch(4),n.abrupt("return",Promise.reject(n.t0));case 11:return e&&this.pluginManager.add(xh(e)),this.calendarPainter.setup(),this.domainCollection=new zy(this.dateHelper),this.navigator.loadNewDomains(this.createDomainCollection(this.options.options.date.start,this.options.options.range)),n.abrupt("return",Promise.allSettled([this.calendarPainter.paint(),this.fill()]));case 16:case"end":return n.stop()}}),n,this,[[4,8]])})))}},{key:"addTemplates",value:function(t){this.templateCollection.add(t)}},{key:"next",value:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:1,e=this.navigator.loadNewDomains(this.createDomainCollection(this.domainCollection.max,t+1).slice(t),wp.SCROLL_FORWARD);return Promise.allSettled([this.calendarPainter.paint(e),this.fill()])}},{key:"previous",value:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:1,e=this.navigator.loadNewDomains(this.createDomainCollection(this.domainCollection.min,-t),wp.SCROLL_BACKWARD);return Promise.allSettled([this.calendarPainter.paint(e),this.fill()])}},{key:"jumpTo",value:function(t){var e=arguments.length>1&&void 0!==arguments[1]&&arguments[1];return Promise.allSettled([this.calendarPainter.paint(this.navigator.jumpTo(t,e)),this.fill()])}},{key:"fill",value:function(){var t=this,e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:this.options.options.data.source,n=this.options.options,r=this.templateCollection,i=this.dateHelper.intervals(n.domain.type,this.domainCollection.max,2)[1],o=this.dataFetcher.getDatas(e,this.domainCollection.min,i);return new Promise((function(e,i){o.then((function(i){t.domainCollection.fill(i,n.data,r.get(n.subDomain.type).extractUnit),t.populator.populate(),e(null)}),(function(t){i(t)}))}))}},{key:"on",value:function(t,e){this.eventEmitter.on(t,e)}},{key:"dimensions",value:function(){return this.calendarPainter.dimensions}},{key:"destroy",value:function(){return this.calendarPainter.destroy()}},{key:"extendDayjs",value:function(t){return this.dateHelper.extend(t)}}]),t}();return Kj.VERSION="4.2.4",Kj}));//# sourceMappingURL=cal-heatmap.min.js.map diff --git a/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.js.map b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.js.map new file mode 100644 index 0000000..bef459c --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/cal-heatmap.min.js.map @@ -0,0 +1 @@ +{"version":3,"file":"cal-heatmap.min.js","sources":["../node_modules/core-js/internals/global.js","../node_modules/core-js/internals/define-global-property.js","../node_modules/core-js/internals/shared-store.js","../node_modules/core-js/internals/shared.js","../node_modules/core-js/internals/engine-v8-version.js","../node_modules/core-js/internals/fails.js","../node_modules/core-js/internals/function-bind-native.js","../node_modules/core-js/internals/function-uncurry-this.js","../node_modules/core-js/internals/is-null-or-undefined.js","../node_modules/core-js/internals/require-object-coercible.js","../node_modules/core-js/internals/to-object.js","../node_modules/core-js/internals/has-own-property.js","../node_modules/core-js/internals/uid.js","../node_modules/core-js/internals/engine-user-agent.js","../node_modules/core-js/internals/symbol-constructor-detection.js","../node_modules/core-js/internals/use-symbol-as-uid.js","../node_modules/core-js/internals/well-known-symbol.js","../node_modules/core-js/internals/to-string-tag-support.js","../node_modules/core-js/internals/document-all.js","../node_modules/core-js/internals/is-callable.js","../node_modules/core-js/internals/descriptors.js","../node_modules/core-js/internals/is-object.js","../node_modules/core-js/internals/document-create-element.js","../node_modules/core-js/internals/ie8-dom-define.js","../node_modules/core-js/internals/v8-prototype-define-bug.js","../node_modules/core-js/internals/an-object.js","../node_modules/core-js/internals/function-call.js","../node_modules/core-js/internals/get-built-in.js","../node_modules/core-js/internals/object-is-prototype-of.js","../node_modules/core-js/internals/is-symbol.js","../node_modules/core-js/internals/try-to-string.js","../node_modules/core-js/internals/a-callable.js","../node_modules/core-js/internals/get-method.js","../node_modules/core-js/internals/ordinary-to-primitive.js","../node_modules/core-js/internals/to-primitive.js","../node_modules/core-js/internals/to-property-key.js","../node_modules/core-js/internals/object-define-property.js","../node_modules/core-js/internals/function-name.js","../node_modules/core-js/internals/inspect-source.js","../node_modules/core-js/internals/internal-state.js","../node_modules/core-js/internals/weak-map-basic-detection.js","../node_modules/core-js/internals/create-property-descriptor.js","../node_modules/core-js/internals/create-non-enumerable-property.js","../node_modules/core-js/internals/shared-key.js","../node_modules/core-js/internals/hidden-keys.js","../node_modules/core-js/internals/make-built-in.js","../node_modules/core-js/internals/define-built-in.js","../node_modules/core-js/internals/classof-raw.js","../node_modules/core-js/internals/classof.js","../node_modules/core-js/internals/object-to-string.js","../node_modules/core-js/modules/es.object.to-string.js","../node_modules/core-js/internals/object-property-is-enumerable.js","../node_modules/core-js/internals/indexed-object.js","../node_modules/core-js/internals/to-indexed-object.js","../node_modules/core-js/internals/object-get-own-property-descriptor.js","../node_modules/core-js/internals/math-trunc.js","../node_modules/core-js/internals/to-integer-or-infinity.js","../node_modules/core-js/internals/to-absolute-index.js","../node_modules/core-js/internals/to-length.js","../node_modules/core-js/internals/length-of-array-like.js","../node_modules/core-js/internals/array-includes.js","../node_modules/core-js/internals/object-keys-internal.js","../node_modules/core-js/internals/enum-bug-keys.js","../node_modules/core-js/internals/object-get-own-property-names.js","../node_modules/core-js/internals/object-get-own-property-symbols.js","../node_modules/core-js/internals/own-keys.js","../node_modules/core-js/internals/copy-constructor-properties.js","../node_modules/core-js/internals/is-forced.js","../node_modules/core-js/internals/export.js","../node_modules/core-js/internals/engine-is-node.js","../node_modules/core-js/internals/function-uncurry-this-accessor.js","../node_modules/core-js/internals/a-possible-prototype.js","../node_modules/core-js/internals/object-set-prototype-of.js","../node_modules/core-js/internals/set-to-string-tag.js","../node_modules/core-js/internals/define-built-in-accessor.js","../node_modules/core-js/internals/set-species.js","../node_modules/core-js/internals/an-instance.js","../node_modules/core-js/internals/is-constructor.js","../node_modules/core-js/internals/task.js","../node_modules/core-js/internals/a-constructor.js","../node_modules/core-js/internals/species-constructor.js","../node_modules/core-js/internals/function-apply.js","../node_modules/core-js/internals/function-uncurry-this-clause.js","../node_modules/core-js/internals/function-bind-context.js","../node_modules/core-js/internals/html.js","../node_modules/core-js/internals/array-slice.js","../node_modules/core-js/internals/validate-arguments-length.js","../node_modules/core-js/internals/engine-is-ios.js","../node_modules/core-js/internals/queue.js","../node_modules/core-js/internals/microtask.js","../node_modules/core-js/internals/engine-is-ios-pebble.js","../node_modules/core-js/internals/engine-is-webos-webkit.js","../node_modules/core-js/internals/perform.js","../node_modules/core-js/internals/promise-native-constructor.js","../node_modules/core-js/internals/engine-is-deno.js","../node_modules/core-js/internals/engine-is-browser.js","../node_modules/core-js/internals/promise-constructor-detection.js","../node_modules/core-js/internals/new-promise-capability.js","../node_modules/core-js/modules/es.promise.constructor.js","../node_modules/core-js/internals/host-report-errors.js","../node_modules/core-js/internals/iterators.js","../node_modules/core-js/internals/is-array-iterator-method.js","../node_modules/core-js/internals/get-iterator-method.js","../node_modules/core-js/internals/get-iterator.js","../node_modules/core-js/internals/iterator-close.js","../node_modules/core-js/internals/iterate.js","../node_modules/core-js/internals/check-correctness-of-iteration.js","../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","../node_modules/core-js/modules/es.promise.all.js","../node_modules/core-js/modules/es.promise.catch.js","../node_modules/core-js/modules/es.promise.race.js","../node_modules/core-js/modules/es.promise.reject.js","../node_modules/core-js/internals/promise-resolve.js","../node_modules/core-js/modules/es.promise.resolve.js","../node_modules/core-js/internals/object-keys.js","../node_modules/core-js/internals/object-define-properties.js","../node_modules/core-js/internals/object-create.js","../node_modules/core-js/internals/add-to-unscopables.js","../node_modules/core-js/internals/iterators-core.js","../node_modules/core-js/internals/correct-prototype-getter.js","../node_modules/core-js/internals/object-get-prototype-of.js","../node_modules/core-js/internals/iterator-create-constructor.js","../node_modules/core-js/internals/iterator-define.js","../node_modules/core-js/internals/create-iter-result-object.js","../node_modules/core-js/modules/es.array.iterator.js","../node_modules/core-js/modules/es.promise.all-settled.js","../node_modules/core-js/internals/to-string.js","../node_modules/core-js/internals/string-multibyte.js","../node_modules/core-js/modules/es.string.iterator.js","../node_modules/core-js/internals/dom-iterables.js","../node_modules/core-js/internals/dom-token-list-prototype.js","../node_modules/core-js/modules/web.dom-collections.iterator.js","../node_modules/core-js/internals/array-fill.js","../node_modules/core-js/modules/es.array.fill.js","../node_modules/core-js/internals/is-array.js","../node_modules/core-js/internals/create-property.js","../node_modules/core-js/internals/array-method-has-species-support.js","../node_modules/core-js/modules/es.array.slice.js","../node_modules/tslib/tslib.es6.js","../node_modules/eventemitter3/index.js","../node_modules/lodash-es/isArray.js","../node_modules/lodash-es/castArray.js","../node_modules/core-js/internals/array-species-constructor.js","../node_modules/core-js/internals/array-species-create.js","../node_modules/core-js/internals/array-iteration.js","../node_modules/core-js/modules/es.array.map.js","../node_modules/core-js/internals/object-assign.js","../node_modules/core-js/modules/es.object.assign.js","../node_modules/core-js/internals/array-slice-simple.js","../node_modules/core-js/internals/object-get-own-property-names-external.js","../node_modules/core-js/internals/array-buffer-non-extensible.js","../node_modules/core-js/internals/object-is-extensible.js","../node_modules/core-js/internals/freezing.js","../node_modules/core-js/internals/internal-metadata.js","../node_modules/core-js/internals/inherit-if-required.js","../node_modules/core-js/internals/collection.js","../node_modules/core-js/internals/define-built-ins.js","../node_modules/core-js/internals/collection-weak.js","../../src/constant.ts","../node_modules/core-js/modules/es.weak-set.constructor.js","../../src/calendar/Navigator.ts","../node_modules/core-js/internals/does-not-exceed-safe-integer.js","../node_modules/core-js/modules/es.array.concat.js","../node_modules/core-js/internals/array-method-is-strict.js","../node_modules/core-js/modules/es.array.join.js","../node_modules/core-js/internals/collection-strong.js","../node_modules/core-js/modules/es.map.constructor.js","../node_modules/core-js/internals/delete-property-or-throw.js","../node_modules/core-js/internals/array-sort.js","../node_modules/core-js/internals/engine-ff-version.js","../node_modules/core-js/internals/engine-is-ie-or-edge.js","../node_modules/core-js/internals/engine-webkit-version.js","../node_modules/core-js/modules/es.array.sort.js","../node_modules/core-js/internals/array-for-each.js","../node_modules/core-js/modules/web.dom-collections.for-each.js","../../src/helpers/PositionHelper.ts","../../src/domain/DomainCoordinates.ts","../../src/domain/DomainPainter.ts","../node_modules/core-js/modules/es.array.includes.js","../node_modules/core-js/modules/es.array.filter.js","../node_modules/core-js/internals/call-with-safe-iteration-closing.js","../node_modules/core-js/internals/array-from.js","../node_modules/core-js/modules/es.array.from.js","../../src/calendar/DomainCollection.ts","../../src/domain/DomainLabelPainter.ts","../node_modules/core-js/internals/whitespaces.js","../node_modules/core-js/internals/string-trim.js","../node_modules/core-js/internals/string-trim-forced.js","../node_modules/core-js/modules/es.string.trim.js","../../src/subDomain/SubDomainPainter.ts","../../src/domain/DomainsContainerPainter.ts","../../src/plugins/PluginPainter.ts","../../src/calendar/CalendarPainter.ts","../node_modules/lodash-es/_freeGlobal.js","../node_modules/lodash-es/_root.js","../node_modules/lodash-es/_Symbol.js","../node_modules/lodash-es/_getRawTag.js","../node_modules/lodash-es/_objectToString.js","../node_modules/lodash-es/_baseGetTag.js","../node_modules/lodash-es/isObject.js","../node_modules/lodash-es/isFunction.js","../node_modules/core-js/modules/es.object.keys.js","../node_modules/core-js/internals/is-regexp.js","../node_modules/core-js/modules/es.string.starts-with.js","../node_modules/core-js/internals/not-a-regexp.js","../node_modules/core-js/internals/correct-is-regexp-logic.js","../node_modules/core-js/internals/object-to-array.js","../node_modules/core-js/modules/es.object.entries.js","../node_modules/@observablehq/plot/src/defined.js","../node_modules/isoformat/src/parse.js","../node_modules/@observablehq/plot/src/time.js","../node_modules/@observablehq/plot/src/options.js","../node_modules/@observablehq/plot/src/scales/index.js","../node_modules/@observablehq/plot/src/symbol.js","../node_modules/@observablehq/plot/src/warnings.js","../node_modules/@observablehq/plot/src/scales/schemes.js","../node_modules/@observablehq/plot/src/scales/quantitative.js","../node_modules/@observablehq/plot/src/scales/diverging.js","../node_modules/@observablehq/plot/src/scales/temporal.js","../node_modules/@observablehq/plot/src/scales/ordinal.js","../node_modules/@observablehq/plot/src/scales.js","../../src/scale.ts","../../src/calendar/Populator.ts","../node_modules/lodash-es/eq.js","../node_modules/lodash-es/_assocIndexOf.js","../node_modules/lodash-es/_listCacheDelete.js","../node_modules/lodash-es/_ListCache.js","../node_modules/lodash-es/_listCacheClear.js","../node_modules/lodash-es/_listCacheGet.js","../node_modules/lodash-es/_listCacheHas.js","../node_modules/lodash-es/_listCacheSet.js","../node_modules/lodash-es/_coreJsData.js","../node_modules/lodash-es/_isMasked.js","../node_modules/lodash-es/_toSource.js","../node_modules/lodash-es/_baseIsNative.js","../node_modules/lodash-es/_getNative.js","../node_modules/lodash-es/_getValue.js","../node_modules/lodash-es/_Map.js","../node_modules/lodash-es/_nativeCreate.js","../node_modules/lodash-es/_hashGet.js","../node_modules/lodash-es/_hashHas.js","../node_modules/lodash-es/_Hash.js","../node_modules/lodash-es/_getMapData.js","../node_modules/lodash-es/_isKeyable.js","../node_modules/lodash-es/_MapCache.js","../node_modules/lodash-es/_hashClear.js","../node_modules/lodash-es/_hashDelete.js","../node_modules/lodash-es/_hashSet.js","../node_modules/lodash-es/_mapCacheClear.js","../node_modules/lodash-es/_mapCacheDelete.js","../node_modules/lodash-es/_mapCacheGet.js","../node_modules/lodash-es/_mapCacheHas.js","../node_modules/lodash-es/_mapCacheSet.js","../node_modules/lodash-es/_Stack.js","../node_modules/lodash-es/_stackClear.js","../node_modules/lodash-es/_stackDelete.js","../node_modules/lodash-es/_stackGet.js","../node_modules/lodash-es/_stackHas.js","../node_modules/lodash-es/_stackSet.js","../node_modules/lodash-es/_defineProperty.js","../node_modules/lodash-es/_baseAssignValue.js","../node_modules/lodash-es/_assignMergeValue.js","../node_modules/lodash-es/_baseFor.js","../node_modules/lodash-es/_createBaseFor.js","../node_modules/lodash-es/_cloneBuffer.js","../node_modules/lodash-es/_Uint8Array.js","../node_modules/lodash-es/_cloneTypedArray.js","../node_modules/lodash-es/_cloneArrayBuffer.js","../node_modules/lodash-es/_baseCreate.js","../node_modules/lodash-es/_overArg.js","../node_modules/lodash-es/_getPrototype.js","../node_modules/lodash-es/_isPrototype.js","../node_modules/lodash-es/isObjectLike.js","../node_modules/lodash-es/_baseIsArguments.js","../node_modules/lodash-es/isArguments.js","../node_modules/lodash-es/isLength.js","../node_modules/lodash-es/isArrayLike.js","../node_modules/lodash-es/isBuffer.js","../node_modules/lodash-es/stubFalse.js","../node_modules/lodash-es/isPlainObject.js","../node_modules/lodash-es/_baseIsTypedArray.js","../node_modules/lodash-es/_nodeUtil.js","../node_modules/lodash-es/_baseUnary.js","../node_modules/lodash-es/isTypedArray.js","../node_modules/lodash-es/_safeGet.js","../node_modules/lodash-es/_assignValue.js","../node_modules/lodash-es/_isIndex.js","../node_modules/lodash-es/_arrayLikeKeys.js","../node_modules/lodash-es/_baseTimes.js","../node_modules/lodash-es/_baseKeysIn.js","../node_modules/lodash-es/_nativeKeysIn.js","../node_modules/lodash-es/keysIn.js","../node_modules/lodash-es/toPlainObject.js","../node_modules/lodash-es/_copyObject.js","../node_modules/lodash-es/_baseMergeDeep.js","../node_modules/lodash-es/isArrayLikeObject.js","../node_modules/lodash-es/_copyArray.js","../node_modules/lodash-es/_initCloneObject.js","../node_modules/lodash-es/_baseMerge.js","../node_modules/lodash-es/identity.js","../node_modules/lodash-es/_overRest.js","../node_modules/lodash-es/_baseSetToString.js","../node_modules/lodash-es/constant.js","../node_modules/lodash-es/_shortOut.js","../node_modules/lodash-es/_setToString.js","../node_modules/lodash-es/_baseRest.js","../node_modules/lodash-es/_apply.js","../node_modules/lodash-es/mergeWith.js","../node_modules/lodash-es/_createAssigner.js","../node_modules/lodash-es/_isIterateeCall.js","../node_modules/lodash-es/_SetCache.js","../node_modules/lodash-es/_arraySome.js","../node_modules/lodash-es/_setCacheAdd.js","../node_modules/lodash-es/_setCacheHas.js","../node_modules/lodash-es/_equalArrays.js","../node_modules/lodash-es/_cacheHas.js","../node_modules/lodash-es/_mapToArray.js","../node_modules/lodash-es/_setToArray.js","../node_modules/lodash-es/_equalByTag.js","../node_modules/lodash-es/_getSymbols.js","../node_modules/lodash-es/_arrayFilter.js","../node_modules/lodash-es/stubArray.js","../node_modules/lodash-es/_nativeKeys.js","../node_modules/lodash-es/_baseKeys.js","../node_modules/lodash-es/keys.js","../node_modules/lodash-es/_getAllKeys.js","../node_modules/lodash-es/_baseGetAllKeys.js","../node_modules/lodash-es/_arrayPush.js","../node_modules/lodash-es/_equalObjects.js","../node_modules/lodash-es/_DataView.js","../node_modules/lodash-es/_Promise.js","../node_modules/lodash-es/_Set.js","../node_modules/lodash-es/_WeakMap.js","../node_modules/lodash-es/_getTag.js","../node_modules/lodash-es/_baseIsEqualDeep.js","../node_modules/lodash-es/_baseIsEqual.js","../node_modules/lodash-es/isEqual.js","../node_modules/lodash-es/_baseHas.js","../node_modules/lodash-es/isSymbol.js","../node_modules/lodash-es/_isKey.js","../node_modules/lodash-es/memoize.js","../node_modules/lodash-es/_stringToPath.js","../node_modules/lodash-es/_memoizeCapped.js","../node_modules/lodash-es/_baseToString.js","../node_modules/lodash-es/_arrayMap.js","../node_modules/lodash-es/_castPath.js","../node_modules/lodash-es/toString.js","../node_modules/lodash-es/_toKey.js","../node_modules/lodash-es/has.js","../node_modules/lodash-es/_hasPath.js","../node_modules/lodash-es/get.js","../node_modules/lodash-es/_baseGet.js","../node_modules/lodash-es/set.js","../node_modules/lodash-es/_baseSet.js","../../src/options/OptionsPreProcessors.ts","../node_modules/core-js/internals/regexp-exec.js","../node_modules/lodash-es/isString.js","../../src/options/Options.ts","../node_modules/core-js/internals/regexp-flags.js","../node_modules/core-js/internals/regexp-sticky-helpers.js","../node_modules/core-js/internals/regexp-unsupported-dot-all.js","../node_modules/core-js/internals/regexp-unsupported-ncg.js","../node_modules/core-js/modules/es.regexp.exec.js","../node_modules/core-js/internals/fix-regexp-well-known-symbol-logic.js","../node_modules/core-js/internals/advance-string-index.js","../node_modules/core-js/internals/get-substitution.js","../node_modules/core-js/internals/regexp-exec-abstract.js","../node_modules/core-js/modules/es.string.replace.js","../../src/DataFetcher.ts","../node_modules/core-js/modules/es.function.name.js","../node_modules/dayjs/dayjs.min.js","../node_modules/dayjs/plugin/weekOfYear.js","../node_modules/dayjs/plugin/dayOfYear.js","../node_modules/dayjs/plugin/weekday.js","../node_modules/dayjs/plugin/minMax.js","../node_modules/dayjs/plugin/isoWeeksInYear.js","../node_modules/dayjs/plugin/isoWeek.js","../node_modules/dayjs/plugin/isLeapYear.js","../node_modules/dayjs/plugin/advancedFormat.js","../node_modules/dayjs/plugin/utc.js","../node_modules/dayjs/plugin/timezone.js","../node_modules/dayjs/plugin/localeData.js","../node_modules/dayjs/plugin/localizedFormat.js","../node_modules/dayjs/plugin/updateLocale.js","../../src/helpers/DateHelper.ts","../node_modules/core-js/modules/es.string.includes.js","../../src/options/OptionsValidator.ts","../node_modules/core-js/modules/es.set.constructor.js","../../src/plugins/PluginManager.ts","../../src/templates/index.ts","../../src/templates/minute.ts","../../src/templates/hour.ts","../../src/templates/day.ts","../../src/templates/xDay.ts","../../src/templates/ghDay.ts","../../src/templates/week.ts","../../src/templates/month.ts","../../src/templates/year.ts","../../src/TemplateCollection.ts","../../src/CalHeatmap.ts","../../src/version.ts"],"sourcesContent":["'use strict';\nvar check = function (it) {\n return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n check(typeof this == 'object' && this) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.34.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',\n license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',\n source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-function-prototype-bind -- safe\n var test = (function () { /* empty */ }).bind();\n // eslint-disable-next-line no-prototype-builtins -- safe\n return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n return function () {\n return call.apply(fn, arguments);\n };\n};\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n return it === null || it === undefined;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n return it;\n};\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol('symbol detection');\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n // of course, fail.\n return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name)) {\n WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n ? Symbol[name]\n : createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar documentAll = typeof document == 'object' && document.all;\n\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nvar IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;\n\nmodule.exports = {\n all: documentAll,\n IS_HTMLDDA: IS_HTMLDDA\n};\n","'use strict';\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = $documentAll.IS_HTMLDDA ? function (argument) {\n return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n return typeof argument == 'function';\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\nmodule.exports = $documentAll.IS_HTMLDDA ? function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;\n} : function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a !== 7;\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype !== 42;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n try {\n return $String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw new $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n /* eslint-disable no-self-assign -- prototype methods protection */\n store.get = store.get;\n store.has = store.has;\n store.set = store.set;\n /* eslint-enable no-self-assign -- prototype methods protection */\n set = function (it, metadata) {\n if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n store.set(it, metadata);\n return metadata;\n };\n get = function (it) {\n return store.get(it) || {};\n };\n has = function (it) {\n return store.has(it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nmodule.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (options && options.getter) name = 'get ' + name;\n if (options && options.setter) name = 'set ' + name;\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n else value.name = name;\n }\n if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n defineProperty(value, 'length', { value: options.arity });\n }\n try {\n if (options && hasOwn(options, 'constructor') && options.constructor) {\n if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n } else if (value.prototype) value.prototype = undefined;\n } catch (error) { /* empty */ }\n var state = enforceInternalState(value);\n if (!hasOwn(state, 'source')) {\n state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- NaN check\n return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el !== el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value !== value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value === POLYFILL ? true\n : value === NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.dontCallGetSet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || defineGlobalProperty(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.dontCallGetSet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n defineBuiltIn(target, key, sourceProperty, options);\n }\n};\n","'use strict';\nvar global = require('../internals/global');\nvar classof = require('../internals/classof-raw');\n\nmodule.exports = classof(global.process) === 'process';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nmodule.exports = function (object, key, method) {\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));\n } catch (error) { /* empty */ }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw new $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","'use strict';\n/* eslint-disable no-proto -- safe */\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (target, TAG, STATIC) {\n if (target && !STATIC) target = target.prototype;\n if (target && !hasOwn(target, TO_STRING_TAG)) {\n defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","'use strict';\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineProperty = require('../internals/object-define-property');\n\nmodule.exports = function (target, name, descriptor) {\n if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });\n if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });\n return defineProperty.f(target, name, descriptor);\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineBuiltInAccessor(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw new $TypeError('Incorrect invocation');\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.test(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n }\n try {\n // we can't check .prototype since constructors produced by .bind haven't it\n // `Function#toString` throws on some built-it function in some legacy engines\n // (for example, `DOMQuad` and similar in FF41-)\n return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n } catch (error) {\n return true;\n }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar $location, defer, channel, port;\n\nfails(function () {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n $location = global.location;\n});\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar eventListener = function (event) {\n run(event.data);\n};\n\nvar globalPostMessageDefer = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), $location.protocol + '//' + $location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(handler) {\n validateArgumentsLength(arguments.length, 1);\n var fn = isCallable(handler) ? handler : Function(handler);\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(fn, undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = eventListener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n $location && $location.protocol !== 'file:' &&\n !fails(globalPostMessageDefer)\n ) {\n defer = globalPostMessageDefer;\n global.addEventListener('message', eventListener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","'use strict';\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a constructor');\n};\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","'use strict';\nvar classofRaw = require('../internals/classof-raw');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (fn) {\n // Nashorn bug:\n // https://github.com/zloirock/core-js/issues/1128\n // https://github.com/zloirock/core-js/issues/1130\n if (classofRaw(fn) === 'Function') return uncurryThis(fn);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","'use strict';\nvar $TypeError = TypeError;\n\nmodule.exports = function (passed, required) {\n if (passed < required) throw new $TypeError('Not enough arguments');\n return passed;\n};\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line redos/no-vulnerable -- safe\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","'use strict';\nvar Queue = function () {\n this.head = null;\n this.tail = null;\n};\n\nQueue.prototype = {\n add: function (item) {\n var entry = { item: item, next: null };\n var tail = this.tail;\n if (tail) tail.next = entry;\n else this.head = entry;\n this.tail = entry;\n },\n get: function () {\n var entry = this.head;\n if (entry) {\n var next = this.head = entry.next;\n if (next === null) this.tail = null;\n return entry.item;\n }\n }\n};\n\nmodule.exports = Queue;\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar Queue = require('../internals/queue');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar microtask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\nvar notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!microtask) {\n var queue = new Queue();\n\n var flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (fn = queue.get()) try {\n fn();\n } catch (error) {\n if (queue.head) notify();\n throw error;\n }\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessage\n // - onreadystatechange\n // - setTimeout\n } else {\n // `webpack` dev server bug on IE global methods - use bind(fn, global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n\n microtask = function (fn) {\n if (!queue.head) notify();\n queue.add(fn);\n };\n}\n\nmodule.exports = microtask;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","'use strict';\nvar global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n && typeof window == 'object'\n && typeof document == 'object';\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n // Detect correctness of subclassing with @@species support\n var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar $TypeError = TypeError;\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar IS_NODE = require('../internals/engine-is-node');\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar perform = require('../internals/perform');\nvar Queue = require('../internals/queue');\nvar InternalStateModule = require('../internals/internal-state');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar PromiseConstructorDetection = require('../internals/promise-constructor-detection');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\n\nvar PROMISE = 'Promise';\nvar FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;\nvar NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;\nvar NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar PromiseConstructor = NativePromiseConstructor;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar callReaction = function (reaction, state) {\n var value = state.value;\n var ok = state.state === FULFILLED;\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(new TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n microtask(function () {\n var reactions = state.reactions;\n var reaction;\n while (reaction = reactions.get()) {\n callReaction(reaction, state);\n }\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw new TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED_PROMISE_CONSTRUCTOR) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalPromiseState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n\n PromisePrototype = PromiseConstructor.prototype;\n\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: new Queue(),\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n state.parent = true;\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n if (state.state === PENDING) state.reactions.add(reaction);\n else microtask(function () {\n callReaction(reaction, state);\n });\n return reaction.promise;\n });\n\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalPromiseState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!NATIVE_PROMISE_SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n","'use strict';\nmodule.exports = function (a, b) {\n try {\n // eslint-disable-next-line no-console -- safe\n arguments.length === 1 ? console.error(a) : console.error(a, b);\n } catch (error) { /* empty */ }\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw new $TypeError(tryToString(argument) + ' is not iterable');\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_RECORD = !!(options && options.IS_RECORD);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_RECORD) {\n iterator = iterable.iterator;\n } else if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = IS_RECORD ? iterable.next : iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n try {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n } catch (error) { return false; } // workaround of old WebKit + `eval` bug\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.all` method\n// https://tc39.es/ecma262/#sec-promise.all\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar defineBuiltIn = require('../internals/define-built-in');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\n\n// `Promise.prototype.catch` method\n// https://tc39.es/ecma262/#sec-promise.prototype.catch\n$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n});\n\n// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromiseConstructor)) {\n var method = getBuiltIn('Promise').prototype['catch'];\n if (NativePromisePrototype['catch'] !== method) {\n defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.race` method\n// https://tc39.es/ecma262/#sec-promise.race\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\n// `Promise.reject` method\n// https://tc39.es/ecma262/#sec-promise.reject\n$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n reject: function reject(r) {\n var capability = newPromiseCapabilityModule.f(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar promiseResolve = require('../internals/promise-resolve');\n\nvar PromiseConstructorWrapper = getBuiltIn('Promise');\nvar CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;\n\n// `Promise.resolve` method\n// https://tc39.es/ecma262/#sec-promise.resolve\n$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {\n resolve: function resolve(x) {\n return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);\n }\n});\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var props = toIndexedObject(Properties);\n var keys = objectKeys(Properties);\n var length = keys.length;\n var index = 0;\n var key;\n while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n return O;\n};\n","'use strict';\n/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n activeXDocument.write(scriptTag(''));\n activeXDocument.close();\n var temp = activeXDocument.parentWindow.Object;\n activeXDocument = null; // avoid memory leak\n return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = documentCreateElement('iframe');\n var JS = 'java' + SCRIPT + ':';\n var iframeDocument;\n iframe.style.display = 'none';\n html.appendChild(iframe);\n // https://github.com/zloirock/core-js/issues/475\n iframe.src = String(JS);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(scriptTag('document.F=Object'));\n iframeDocument.close();\n return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n try {\n activeXDocument = new ActiveXObject('htmlfile');\n } catch (error) { /* ignore */ }\n NullProtoObject = typeof document != 'undefined'\n ? document.domain && activeXDocument\n ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n : NullProtoObjectViaIFrame()\n : NullProtoObjectViaActiveX(activeXDocument); // WSH\n var length = enumBugKeys.length;\n while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n EmptyConstructor[PROTOTYPE] = anObject(O);\n result = new EmptyConstructor();\n EmptyConstructor[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = NullProtoObject();\n return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] === undefined) {\n defineProperty(ArrayPrototype, UNSCOPABLES, {\n configurable: true,\n value: create(null)\n });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n arrayIterator = [].keys();\n // Safari 8 has buggy iterators w/o `next`\n if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n else {\n PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {\n var test = {};\n // FF44- legacy iterators case\n return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n defineBuiltIn(IteratorPrototype, ITERATOR, function () {\n return this;\n });\n}\n\nmodule.exports = {\n IteratorPrototype: IteratorPrototype,\n BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n function F() { /* empty */ }\n F.prototype.constructor = null;\n // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar $Object = Object;\nvar ObjectPrototype = $Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n// eslint-disable-next-line es/no-object-getprototypeof -- safe\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {\n var object = toObject(O);\n if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n var constructor = object.constructor;\n if (isCallable(constructor) && object instanceof constructor) {\n return constructor.prototype;\n } return object instanceof $Object ? ObjectPrototype : null;\n};\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {\n var TO_STRING_TAG = NAME + ' Iterator';\n IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });\n setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n Iterators[TO_STRING_TAG] = returnThis;\n return IteratorConstructor;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/iterator-create-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n createIteratorConstructor(IteratorConstructor, NAME, next);\n\n var getIterationMethod = function (KIND) {\n if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];\n\n switch (KIND) {\n case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n }\n\n return function () { return new IteratorConstructor(this); };\n };\n\n var TO_STRING_TAG = NAME + ' Iterator';\n var INCORRECT_VALUES_NAME = false;\n var IterablePrototype = Iterable.prototype;\n var nativeIterator = IterablePrototype[ITERATOR]\n || IterablePrototype['@@iterator']\n || DEFAULT && IterablePrototype[DEFAULT];\n var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n var CurrentIteratorPrototype, methods, KEY;\n\n // fix native\n if (anyNativeIterator) {\n CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n if (setPrototypeOf) {\n setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);\n }\n }\n // Set @@toStringTag to native iterators\n setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n }\n }\n\n // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n } else {\n INCORRECT_VALUES_NAME = true;\n defaultIterator = function values() { return call(nativeIterator, this); };\n }\n }\n\n // export additional methods\n if (DEFAULT) {\n methods = {\n values: getIterationMethod(VALUES),\n keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n entries: getIterationMethod(ENTRIES)\n };\n if (FORCED) for (KEY in methods) {\n if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n defineBuiltIn(IterablePrototype, KEY, methods[KEY]);\n }\n } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n }\n\n // define iterator\n if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n }\n Iterators[NAME] = defaultIterator;\n\n return methods;\n};\n","'use strict';\n// `CreateIterResultObject` abstract operation\n// https://tc39.es/ecma262/#sec-createiterresultobject\nmodule.exports = function (value, done) {\n return { value: value, done: done };\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineProperty = require('../internals/object-define-property').f;\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar IS_PURE = require('../internals/is-pure');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n setInternalState(this, {\n type: ARRAY_ITERATOR,\n target: toIndexedObject(iterated), // target\n index: 0, // next index\n kind: kind // kind\n });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n var state = getInternalState(this);\n var target = state.target;\n var index = state.index++;\n if (!target || index >= target.length) {\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n switch (state.kind) {\n case 'keys': return createIterResultObject(index, false);\n case 'values': return createIterResultObject(target[index], false);\n } return createIterResultObject([index, target[index]], false);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nvar values = Iterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n// V8 ~ Chrome 45- bug\nif (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {\n defineProperty(values, 'name', { value: 'values' });\n} catch (error) { /* empty */ }\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-promise.allsettled\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n allSettled: function allSettled(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call(promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = { status: 'fulfilled', value: value };\n --remaining || resolve(values);\n }, function (error) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = { status: 'rejected', reason: error };\n --remaining || resolve(values);\n });\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar classof = require('../internals/classof');\n\nvar $String = String;\n\nmodule.exports = function (argument) {\n if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n return $String(argument);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n return function ($this, pos) {\n var S = toString(requireObjectCoercible($this));\n var position = toIntegerOrInfinity(pos);\n var size = S.length;\n var first, second;\n if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n first = charCodeAt(S, position);\n return first < 0xD800 || first > 0xDBFF || position + 1 === size\n || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n ? CONVERT_TO_STRING\n ? charAt(S, position)\n : first\n : CONVERT_TO_STRING\n ? stringSlice(S, position, position + 2)\n : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n };\n};\n\nmodule.exports = {\n // `String.prototype.codePointAt` method\n // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n codeAt: createMethod(false),\n // `String.prototype.at` method\n // https://github.com/mathiasbynens/String.prototype.at\n charAt: createMethod(true)\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n setInternalState(this, {\n type: STRING_ITERATOR,\n string: toString(iterated),\n index: 0\n });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n var state = getInternalState(this);\n var string = state.string;\n var index = state.index;\n var point;\n if (index >= string.length) return createIterResultObject(undefined, true);\n point = charAt(string, index);\n state.index += point.length;\n return createIterResultObject(point, false);\n});\n","'use strict';\n// iterable DOM collections\n// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods\nmodule.exports = {\n CSSRuleList: 0,\n CSSStyleDeclaration: 0,\n CSSValueList: 0,\n ClientRectList: 0,\n DOMRectList: 0,\n DOMStringList: 0,\n DOMTokenList: 1,\n DataTransferItemList: 0,\n FileList: 0,\n HTMLAllCollection: 0,\n HTMLCollection: 0,\n HTMLFormElement: 0,\n HTMLSelectElement: 0,\n MediaList: 0,\n MimeTypeArray: 0,\n NamedNodeMap: 0,\n NodeList: 1,\n PaintRequestList: 0,\n Plugin: 0,\n PluginArray: 0,\n SVGLengthList: 0,\n SVGNumberList: 0,\n SVGPathSegList: 0,\n SVGPointList: 0,\n SVGStringList: 0,\n SVGTransformList: 0,\n SourceBufferList: 0,\n StyleSheetList: 0,\n TextTrackCueList: 0,\n TextTrackList: 0,\n TouchList: 0\n};\n","'use strict';\n// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`\nvar documentCreateElement = require('../internals/document-create-element');\n\nvar classList = documentCreateElement('span').classList;\nvar DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;\n\nmodule.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nvar handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {\n if (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n } catch (error) {\n CollectionPrototype[ITERATOR] = ArrayValues;\n }\n setToStringTag(CollectionPrototype, COLLECTION_NAME, true);\n if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n } catch (error) {\n CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n }\n }\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);\n}\n\nhandlePrototype(DOMTokenListPrototype, 'DOMTokenList');\n","'use strict';\nvar toObject = require('../internals/to-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.fill` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.fill\nmodule.exports = function fill(value /* , start = 0, end = @length */) {\n var O = toObject(this);\n var length = lengthOfArrayLike(O);\n var argumentsLength = arguments.length;\n var index = toAbsoluteIndex(argumentsLength > 1 ? arguments[1] : undefined, length);\n var end = argumentsLength > 2 ? arguments[2] : undefined;\n var endPos = end === undefined ? length : toAbsoluteIndex(end, length);\n while (endPos > index) O[index++] = value;\n return O;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar fill = require('../internals/array-fill');\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// `Array.prototype.fill` method\n// https://tc39.es/ecma262/#sec-array.prototype.fill\n$({ target: 'Array', proto: true }, {\n fill: fill\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('fill');\n","'use strict';\nvar classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n return classof(argument) === 'Array';\n};\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n var propertyKey = toPropertyKey(key);\n if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n else object[propertyKey] = value;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (METHOD_NAME) {\n // We can't use this feature detection in V8 since it causes\n // deoptimization and serious performance degradation\n // https://github.com/zloirock/core-js/issues/677\n return V8_VERSION >= 51 || !fails(function () {\n var array = [];\n var constructor = array.constructor = {};\n constructor[SPECIES] = function () {\n return { foo: 1 };\n };\n return array[METHOD_NAME](Boolean).foo !== 1;\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar createProperty = require('../internals/create-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar nativeSlice = require('../internals/array-slice');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\nvar max = Math.max;\n\n// `Array.prototype.slice` method\n// https://tc39.es/ecma262/#sec-array.prototype.slice\n// fallback for not array-like ES3 strings and DOM objects\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n slice: function slice(start, end) {\n var O = toIndexedObject(this);\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible\n var Constructor, result, n;\n if (isArray(O)) {\n Constructor = O.constructor;\n // cross-realm fallback\n if (isConstructor(Constructor) && (Constructor === $Array || isArray(Constructor.prototype))) {\n Constructor = undefined;\n } else if (isObject(Constructor)) {\n Constructor = Constructor[SPECIES];\n if (Constructor === null) Constructor = undefined;\n }\n if (Constructor === $Array || Constructor === undefined) {\n return nativeSlice(O, k, fin);\n }\n }\n result = new (Constructor === undefined ? $Array : Constructor)(max(fin - k, 0));\n for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n }\n});\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n var _, done = false;\r\n for (var i = decorators.length - 1; i >= 0; i--) {\r\n var context = {};\r\n for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n if (kind === \"accessor\") {\r\n if (result === void 0) continue;\r\n if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n if (_ = accept(result.get)) descriptor.get = _;\r\n if (_ = accept(result.set)) descriptor.set = _;\r\n if (_ = accept(result.init)) initializers.unshift(_);\r\n }\r\n else if (_ = accept(result)) {\r\n if (kind === \"field\") initializers.unshift(_);\r\n else descriptor[key] = _;\r\n }\r\n }\r\n if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n var useValue = arguments.length > 2;\r\n for (var i = 0; i < initializers.length; i++) {\r\n value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n }\r\n return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n 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;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n var desc = Object.getOwnPropertyDescriptor(m, k);\r\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n desc = { enumerable: true, get: function() { return m[k]; } };\r\n }\r\n Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport default {\r\n __extends,\r\n __assign,\r\n __rest,\r\n __decorate,\r\n __param,\r\n __metadata,\r\n __awaiter,\r\n __generator,\r\n __createBinding,\r\n __exportStar,\r\n __values,\r\n __read,\r\n __spread,\r\n __spreadArrays,\r\n __spreadArray,\r\n __await,\r\n __asyncGenerator,\r\n __asyncDelegator,\r\n __asyncValues,\r\n __makeTemplateObject,\r\n __importStar,\r\n __importDefault,\r\n __classPrivateFieldGet,\r\n __classPrivateFieldSet,\r\n __classPrivateFieldIn,\r\n};\r\n","'use strict';\n\nvar has = Object.prototype.hasOwnProperty\n , prefix = '~';\n\n/**\n * Constructor to create a storage for our `EE` objects.\n * An `Events` instance is a plain object whose properties are event names.\n *\n * @constructor\n * @private\n */\nfunction Events() {}\n\n//\n// We try to not inherit from `Object.prototype`. In some engines creating an\n// instance in this way is faster than calling `Object.create(null)` directly.\n// If `Object.create(null)` is not supported we prefix the event names with a\n// character to make sure that the built-in object properties are not\n// overridden or used as an attack vector.\n//\nif (Object.create) {\n Events.prototype = Object.create(null);\n\n //\n // This hack is needed because the `__proto__` property is still inherited in\n // some old browsers like Android 4, iPhone 5.1, Opera 11 and Safari 5.\n //\n if (!new Events().__proto__) prefix = false;\n}\n\n/**\n * Representation of a single event listener.\n *\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} [once=false] Specify if the listener is a one-time listener.\n * @constructor\n * @private\n */\nfunction EE(fn, context, once) {\n this.fn = fn;\n this.context = context;\n this.once = once || false;\n}\n\n/**\n * Add a listener for a given event.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} context The context to invoke the listener with.\n * @param {Boolean} once Specify if the listener is a one-time listener.\n * @returns {EventEmitter}\n * @private\n */\nfunction addListener(emitter, event, fn, context, once) {\n if (typeof fn !== 'function') {\n throw new TypeError('The listener must be a function');\n }\n\n var listener = new EE(fn, context || emitter, once)\n , evt = prefix ? prefix + event : event;\n\n if (!emitter._events[evt]) emitter._events[evt] = listener, emitter._eventsCount++;\n else if (!emitter._events[evt].fn) emitter._events[evt].push(listener);\n else emitter._events[evt] = [emitter._events[evt], listener];\n\n return emitter;\n}\n\n/**\n * Clear event by name.\n *\n * @param {EventEmitter} emitter Reference to the `EventEmitter` instance.\n * @param {(String|Symbol)} evt The Event name.\n * @private\n */\nfunction clearEvent(emitter, evt) {\n if (--emitter._eventsCount === 0) emitter._events = new Events();\n else delete emitter._events[evt];\n}\n\n/**\n * Minimal `EventEmitter` interface that is molded against the Node.js\n * `EventEmitter` interface.\n *\n * @constructor\n * @public\n */\nfunction EventEmitter() {\n this._events = new Events();\n this._eventsCount = 0;\n}\n\n/**\n * Return an array listing the events for which the emitter has registered\n * listeners.\n *\n * @returns {Array}\n * @public\n */\nEventEmitter.prototype.eventNames = function eventNames() {\n var names = []\n , events\n , name;\n\n if (this._eventsCount === 0) return names;\n\n for (name in (events = this._events)) {\n if (has.call(events, name)) names.push(prefix ? name.slice(1) : name);\n }\n\n if (Object.getOwnPropertySymbols) {\n return names.concat(Object.getOwnPropertySymbols(events));\n }\n\n return names;\n};\n\n/**\n * Return the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Array} The registered listeners.\n * @public\n */\nEventEmitter.prototype.listeners = function listeners(event) {\n var evt = prefix ? prefix + event : event\n , handlers = this._events[evt];\n\n if (!handlers) return [];\n if (handlers.fn) return [handlers.fn];\n\n for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {\n ee[i] = handlers[i].fn;\n }\n\n return ee;\n};\n\n/**\n * Return the number of listeners listening to a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Number} The number of listeners.\n * @public\n */\nEventEmitter.prototype.listenerCount = function listenerCount(event) {\n var evt = prefix ? prefix + event : event\n , listeners = this._events[evt];\n\n if (!listeners) return 0;\n if (listeners.fn) return 1;\n return listeners.length;\n};\n\n/**\n * Calls each of the listeners registered for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @returns {Boolean} `true` if the event had listeners, else `false`.\n * @public\n */\nEventEmitter.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {\n var evt = prefix ? prefix + event : event;\n\n if (!this._events[evt]) return false;\n\n var listeners = this._events[evt]\n , len = arguments.length\n , args\n , i;\n\n if (listeners.fn) {\n if (listeners.once) this.removeListener(event, listeners.fn, undefined, true);\n\n switch (len) {\n case 1: return listeners.fn.call(listeners.context), true;\n case 2: return listeners.fn.call(listeners.context, a1), true;\n case 3: return listeners.fn.call(listeners.context, a1, a2), true;\n case 4: return listeners.fn.call(listeners.context, a1, a2, a3), true;\n case 5: return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;\n case 6: return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;\n }\n\n for (i = 1, args = new Array(len -1); i < len; i++) {\n args[i - 1] = arguments[i];\n }\n\n listeners.fn.apply(listeners.context, args);\n } else {\n var length = listeners.length\n , j;\n\n for (i = 0; i < length; i++) {\n if (listeners[i].once) this.removeListener(event, listeners[i].fn, undefined, true);\n\n switch (len) {\n case 1: listeners[i].fn.call(listeners[i].context); break;\n case 2: listeners[i].fn.call(listeners[i].context, a1); break;\n case 3: listeners[i].fn.call(listeners[i].context, a1, a2); break;\n case 4: listeners[i].fn.call(listeners[i].context, a1, a2, a3); break;\n default:\n if (!args) for (j = 1, args = new Array(len -1); j < len; j++) {\n args[j - 1] = arguments[j];\n }\n\n listeners[i].fn.apply(listeners[i].context, args);\n }\n }\n }\n\n return true;\n};\n\n/**\n * Add a listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.on = function on(event, fn, context) {\n return addListener(this, event, fn, context, false);\n};\n\n/**\n * Add a one-time listener for a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn The listener function.\n * @param {*} [context=this] The context to invoke the listener with.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.once = function once(event, fn, context) {\n return addListener(this, event, fn, context, true);\n};\n\n/**\n * Remove the listeners of a given event.\n *\n * @param {(String|Symbol)} event The event name.\n * @param {Function} fn Only remove the listeners that match this function.\n * @param {*} context Only remove the listeners that have this context.\n * @param {Boolean} once Only remove one-time listeners.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeListener = function removeListener(event, fn, context, once) {\n var evt = prefix ? prefix + event : event;\n\n if (!this._events[evt]) return this;\n if (!fn) {\n clearEvent(this, evt);\n return this;\n }\n\n var listeners = this._events[evt];\n\n if (listeners.fn) {\n if (\n listeners.fn === fn &&\n (!once || listeners.once) &&\n (!context || listeners.context === context)\n ) {\n clearEvent(this, evt);\n }\n } else {\n for (var i = 0, events = [], length = listeners.length; i < length; i++) {\n if (\n listeners[i].fn !== fn ||\n (once && !listeners[i].once) ||\n (context && listeners[i].context !== context)\n ) {\n events.push(listeners[i]);\n }\n }\n\n //\n // Reset the array, or remove it completely if we have no more listeners.\n //\n if (events.length) this._events[evt] = events.length === 1 ? events[0] : events;\n else clearEvent(this, evt);\n }\n\n return this;\n};\n\n/**\n * Remove all listeners, or those of the specified event.\n *\n * @param {(String|Symbol)} [event] The event name.\n * @returns {EventEmitter} `this`.\n * @public\n */\nEventEmitter.prototype.removeAllListeners = function removeAllListeners(event) {\n var evt;\n\n if (event) {\n evt = prefix ? prefix + event : event;\n if (this._events[evt]) clearEvent(this, evt);\n } else {\n this._events = new Events();\n this._eventsCount = 0;\n }\n\n return this;\n};\n\n//\n// Alias methods names because people roll like that.\n//\nEventEmitter.prototype.off = EventEmitter.prototype.removeListener;\nEventEmitter.prototype.addListener = EventEmitter.prototype.on;\n\n//\n// Expose the prefix.\n//\nEventEmitter.prefixed = prefix;\n\n//\n// Allow `EventEmitter` to be imported as module namespace.\n//\nEventEmitter.EventEmitter = EventEmitter;\n\n//\n// Expose the module.\n//\nif ('undefined' !== typeof module) {\n module.exports = EventEmitter;\n}\n","/**\n * Checks if `value` is classified as an `Array` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array, else `false`.\n * @example\n *\n * _.isArray([1, 2, 3]);\n * // => true\n *\n * _.isArray(document.body.children);\n * // => false\n *\n * _.isArray('abc');\n * // => false\n *\n * _.isArray(_.noop);\n * // => false\n */\nvar isArray = Array.isArray;\n\nexport default isArray;\n","import isArray from './isArray.js';\n\n/**\n * Casts `value` as an array if it's not one.\n *\n * @static\n * @memberOf _\n * @since 4.4.0\n * @category Lang\n * @param {*} value The value to inspect.\n * @returns {Array} Returns the cast array.\n * @example\n *\n * _.castArray(1);\n * // => [1]\n *\n * _.castArray({ 'a': 1 });\n * // => [{ 'a': 1 }]\n *\n * _.castArray('abc');\n * // => ['abc']\n *\n * _.castArray(null);\n * // => [null]\n *\n * _.castArray(undefined);\n * // => [undefined]\n *\n * _.castArray();\n * // => []\n *\n * var array = [1, 2, 3];\n * console.log(_.castArray(array) === array);\n * // => true\n */\nfunction castArray() {\n if (!arguments.length) {\n return [];\n }\n var value = arguments[0];\n return isArray(value) ? value : [value];\n}\n\nexport default castArray;\n","'use strict';\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n var C;\n if (isArray(originalArray)) {\n C = originalArray.constructor;\n // cross-realm fallback\n if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;\n else if (isObject(C)) {\n C = C[SPECIES];\n if (C === null) C = undefined;\n }\n } return C === undefined ? $Array : C;\n};\n","'use strict';\nvar arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n var IS_MAP = TYPE === 1;\n var IS_FILTER = TYPE === 2;\n var IS_SOME = TYPE === 3;\n var IS_EVERY = TYPE === 4;\n var IS_FIND_INDEX = TYPE === 6;\n var IS_FILTER_REJECT = TYPE === 7;\n var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;\n return function ($this, callbackfn, that, specificCreate) {\n var O = toObject($this);\n var self = IndexedObject(O);\n var length = lengthOfArrayLike(self);\n var boundFunction = bind(callbackfn, that);\n var index = 0;\n var create = specificCreate || arraySpeciesCreate;\n var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n var value, result;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n value = self[index];\n result = boundFunction(value, index, O);\n if (TYPE) {\n if (IS_MAP) target[index] = result; // map\n else if (result) switch (TYPE) {\n case 3: return true; // some\n case 5: return value; // find\n case 6: return index; // findIndex\n case 2: push(target, value); // filter\n } else switch (TYPE) {\n case 4: return false; // every\n case 7: push(target, value); // filterReject\n }\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.forEach` method\n // https://tc39.es/ecma262/#sec-array.prototype.foreach\n forEach: createMethod(0),\n // `Array.prototype.map` method\n // https://tc39.es/ecma262/#sec-array.prototype.map\n map: createMethod(1),\n // `Array.prototype.filter` method\n // https://tc39.es/ecma262/#sec-array.prototype.filter\n filter: createMethod(2),\n // `Array.prototype.some` method\n // https://tc39.es/ecma262/#sec-array.prototype.some\n some: createMethod(3),\n // `Array.prototype.every` method\n // https://tc39.es/ecma262/#sec-array.prototype.every\n every: createMethod(4),\n // `Array.prototype.find` method\n // https://tc39.es/ecma262/#sec-array.prototype.find\n find: createMethod(5),\n // `Array.prototype.findIndex` method\n // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n findIndex: createMethod(6),\n // `Array.prototype.filterReject` method\n // https://github.com/tc39/proposal-array-filtering\n filterReject: createMethod(7)\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $map = require('../internals/array-iteration').map;\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');\n\n// `Array.prototype.map` method\n// https://tc39.es/ecma262/#sec-array.prototype.map\n// with adding support of @@species\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n map: function map(callbackfn /* , thisArg */) {\n return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol('assign detection');\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","'use strict';\nvar $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {\n assign: assign\n});\n","'use strict';\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\n\nvar $Array = Array;\nvar max = Math.max;\n\nmodule.exports = function (O, start, end) {\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n var result = $Array(max(fin - k, 0));\n var n = 0;\n for (; k < fin; k++, n++) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n};\n","'use strict';\n/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n try {\n return $getOwnPropertyNames(it);\n } catch (error) {\n return arraySlice(windowNames);\n }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n return windowNames && classof(it) === 'Window'\n ? getWindowNames(it)\n : $getOwnPropertyNames(toIndexedObject(it));\n};\n","'use strict';\n// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it\nvar fails = require('../internals/fails');\n\nmodule.exports = fails(function () {\n if (typeof ArrayBuffer == 'function') {\n var buffer = new ArrayBuffer(8);\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe\n if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar ARRAY_BUFFER_NON_EXTENSIBLE = require('../internals/array-buffer-non-extensible');\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar $isExtensible = Object.isExtensible;\nvar FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); });\n\n// `Object.isExtensible` method\n// https://tc39.es/ecma262/#sec-object.isextensible\nmodule.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) {\n if (!isObject(it)) return false;\n if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false;\n return $isExtensible ? $isExtensible(it) : true;\n} : $isExtensible;\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n return Object.isExtensible(Object.preventExtensions({}));\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar isExtensible = require('../internals/object-is-extensible');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar setMetadata = function (it) {\n defineProperty(it, METADATA, { value: {\n objectID: 'O' + id++, // object ID\n weakData: {} // weak collections IDs\n } });\n};\n\nvar fastKey = function (it, create) {\n // return a primitive with prefix\n if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return 'F';\n // not necessary to add metadata\n if (!create) return 'E';\n // add missing metadata\n setMetadata(it);\n // return object ID\n } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return true;\n // not necessary to add metadata\n if (!create) return false;\n // add missing metadata\n setMetadata(it);\n // return the store of weak collections IDs\n } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n return it;\n};\n\nvar enable = function () {\n meta.enable = function () { /* empty */ };\n REQUIRED = true;\n var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n var splice = uncurryThis([].splice);\n var test = {};\n test[METADATA] = 1;\n\n // prevent exposing of metadata key\n if (getOwnPropertyNames(test).length) {\n getOwnPropertyNamesModule.f = function (it) {\n var result = getOwnPropertyNames(it);\n for (var i = 0, length = result.length; i < length; i++) {\n if (result[i] === METADATA) {\n splice(result, i, 1);\n break;\n }\n } return result;\n };\n\n $({ target: 'Object', stat: true, forced: true }, {\n getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n });\n }\n};\n\nvar meta = module.exports = {\n enable: enable,\n fastKey: fastKey,\n getWeakData: getWeakData,\n onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n var NewTarget, NewTargetPrototype;\n if (\n // it can work only with native `setPrototypeOf`\n setPrototypeOf &&\n // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n isCallable(NewTarget = dummy.constructor) &&\n NewTarget !== Wrapper &&\n isObject(NewTargetPrototype = NewTarget.prototype) &&\n NewTargetPrototype !== Wrapper.prototype\n ) setPrototypeOf($this, NewTargetPrototype);\n return $this;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n var ADDER = IS_MAP ? 'set' : 'add';\n var NativeConstructor = global[CONSTRUCTOR_NAME];\n var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n var Constructor = NativeConstructor;\n var exported = {};\n\n var fixMethod = function (KEY) {\n var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n defineBuiltIn(NativePrototype, KEY,\n KEY === 'add' ? function add(value) {\n uncurriedNativeMethod(this, value === 0 ? 0 : value);\n return this;\n } : KEY === 'delete' ? function (key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'get' ? function get(key) {\n return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'has' ? function has(key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : function set(key, value) {\n uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n return this;\n }\n );\n };\n\n var REPLACE = isForced(\n CONSTRUCTOR_NAME,\n !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n new NativeConstructor().entries().next();\n }))\n );\n\n if (REPLACE) {\n // create collection constructor\n Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n InternalMetadataModule.enable();\n } else if (isForced(CONSTRUCTOR_NAME, true)) {\n var instance = new Constructor();\n // early implementations not supports chaining\n var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance;\n // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n // most early implementations doesn't supports iterables, most modern - not close it correctly\n // eslint-disable-next-line no-new -- required for testing\n var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n // for early implementations -0 and +0 not the same\n var BUGGY_ZERO = !IS_WEAK && fails(function () {\n // V8 ~ Chromium 42- fails only with 5+ elements\n var $instance = new NativeConstructor();\n var index = 5;\n while (index--) $instance[ADDER](index, index);\n return !$instance.has(-0);\n });\n\n if (!ACCEPT_ITERABLES) {\n Constructor = wrapper(function (dummy, iterable) {\n anInstance(dummy, NativePrototype);\n var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n return that;\n });\n Constructor.prototype = NativePrototype;\n NativePrototype.constructor = Constructor;\n }\n\n if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n fixMethod('delete');\n fixMethod('has');\n IS_MAP && fixMethod('get');\n }\n\n if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n // weak collections should not contains .clear method\n if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n }\n\n exported[CONSTRUCTOR_NAME] = Constructor;\n $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported);\n\n setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n return Constructor;\n};\n","'use strict';\nvar defineBuiltIn = require('../internals/define-built-in');\n\nmodule.exports = function (target, src, options) {\n for (var key in src) defineBuiltIn(target, key, src[key], options);\n return target;\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar getWeakData = require('../internals/internal-metadata').getWeakData;\nvar anInstance = require('../internals/an-instance');\nvar anObject = require('../internals/an-object');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar iterate = require('../internals/iterate');\nvar ArrayIterationModule = require('../internals/array-iteration');\nvar hasOwn = require('../internals/has-own-property');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\nvar find = ArrayIterationModule.find;\nvar findIndex = ArrayIterationModule.findIndex;\nvar splice = uncurryThis([].splice);\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (state) {\n return state.frozen || (state.frozen = new UncaughtFrozenStore());\n};\n\nvar UncaughtFrozenStore = function () {\n this.entries = [];\n};\n\nvar findUncaughtFrozen = function (store, key) {\n return find(store.entries, function (it) {\n return it[0] === key;\n });\n};\n\nUncaughtFrozenStore.prototype = {\n get: function (key) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) return entry[1];\n },\n has: function (key) {\n return !!findUncaughtFrozen(this, key);\n },\n set: function (key, value) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) entry[1] = value;\n else this.entries.push([key, value]);\n },\n 'delete': function (key) {\n var index = findIndex(this.entries, function (it) {\n return it[0] === key;\n });\n if (~index) splice(this.entries, index, 1);\n return !!~index;\n }\n};\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n id: id++,\n frozen: undefined\n });\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var data = getWeakData(anObject(key), true);\n if (data === true) uncaughtFrozenStore(state).set(key, value);\n else data[state.id] = value;\n return that;\n };\n\n defineBuiltIns(Prototype, {\n // `{ WeakMap, WeakSet }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.delete\n // https://tc39.es/ecma262/#sec-weakset.prototype.delete\n 'delete': function (key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state)['delete'](key);\n return data && hasOwn(data, state.id) && delete data[state.id];\n },\n // `{ WeakMap, WeakSet }.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.has\n // https://tc39.es/ecma262/#sec-weakset.prototype.has\n has: function has(key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).has(key);\n return data && hasOwn(data, state.id);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `WeakMap.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.get\n get: function get(key) {\n var state = getInternalState(this);\n if (isObject(key)) {\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).get(key);\n return data ? data[state.id] : undefined;\n }\n },\n // `WeakMap.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.set\n set: function set(key, value) {\n return define(this, key, value);\n }\n } : {\n // `WeakSet.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-weakset.prototype.add\n add: function add(value) {\n return define(this, value, true);\n }\n });\n\n return Constructor;\n }\n};\n","export enum ScrollDirection {\n SCROLL_NONE,\n SCROLL_BACKWARD,\n SCROLL_FORWARD,\n}\n\nexport enum Position {\n TOP,\n RIGHT,\n BOTTOM,\n LEFT,\n}\n\nexport const OPTIONS_DEFAULT_DOMAIN_TYPE = 'hour';\n\nexport const OPTIONS_DEFAULT_SUBDOMAIN_TYPE = 'minute';\nexport const OPTIONS_DEFAULT_SUBDOMAIN_WIDTH = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_GUTTER = 2;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_RADIUS = 0;\nexport const OPTIONS_DEFAULT_ANIMATION_DURATION = 200;\nexport const OPTIONS_DEFAULT_RANGE = 12;\nexport const OPTIONS_DEFAULT_ITEM_SELECTOR = '#cal-heatmap';\nexport const OPTIONS_DEFAULT_THEME = 'light';\nexport const OPTIONS_DEFAULT_LOCALE = 'en';\n\nexport const SCALE_BASE_OPACITY_COLOR = 'red';\nexport const SCALE_BASE_COLOR_SCHEME = 'YlOrBr';\nexport const SCALE_BASE_COLOR_TYPE = 'quantize';\nexport const SCALE_BASE_COLOR_DOMAIN = [0, 100];\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionWeak = require('../internals/collection-weak');\n\n// `WeakSet` constructor\n// https://tc39.es/ecma262/#sec-weakset-constructor\ncollection('WeakSet', function (init) {\n return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionWeak);\n","import { ScrollDirection } from '../constant';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type DomainCollection from './DomainCollection';\nimport type { Timestamp } from '../index';\n\nexport default class Navigator {\n calendar: CalHeatmap;\n\n minDomainReached: boolean;\n\n maxDomainReached: boolean;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.maxDomainReached = false;\n this.minDomainReached = false;\n }\n\n loadNewDomains(\n newDomainCollection: DomainCollection,\n direction: ScrollDirection = ScrollDirection.SCROLL_NONE,\n ): ScrollDirection {\n const { options } = this.calendar.options;\n const templatesClt = this.calendar.templateCollection;\n const minDate = options.date.min ?\n templatesClt.get(options.domain.type)!.extractUnit(+options.date.min) :\n undefined;\n const maxDate = options.date.max ?\n templatesClt.get(options.domain.type)!.extractUnit(+options.date.max) :\n undefined;\n const { domainCollection } = this.calendar;\n\n if (\n this.#isDomainBoundaryReached(\n newDomainCollection,\n minDate,\n maxDate,\n direction,\n )\n ) {\n return ScrollDirection.SCROLL_NONE;\n }\n\n if (direction !== ScrollDirection.SCROLL_NONE) {\n newDomainCollection\n .clamp(minDate, maxDate)\n .slice(options.range, direction === ScrollDirection.SCROLL_FORWARD);\n }\n\n domainCollection.merge(\n newDomainCollection,\n options.range,\n (domainKey: Timestamp, index: number) => {\n let subDomainEndDate = null;\n if (newDomainCollection.at(index + 1)) {\n subDomainEndDate = newDomainCollection.at(index + 1);\n } else {\n subDomainEndDate = this.calendar.dateHelper\n .intervals(options.domain.type, domainKey, 2)\n .pop();\n }\n return templatesClt\n .get(options.subDomain.type)!\n .mapping(domainKey, subDomainEndDate!)\n .map((d) => ({ ...d, v: options.data.defaultValue }));\n },\n );\n\n this.#setDomainsBoundaryReached(\n domainCollection.min,\n domainCollection.max,\n minDate,\n maxDate,\n );\n\n if (direction === ScrollDirection.SCROLL_BACKWARD) {\n this.calendar.eventEmitter.emit('domainsLoaded', [domainCollection.min]);\n } else if (direction === ScrollDirection.SCROLL_FORWARD) {\n this.calendar.eventEmitter.emit('domainsLoaded', [domainCollection.max]);\n }\n\n return direction;\n }\n\n jumpTo(date: Date, reset: boolean): ScrollDirection {\n const { domainCollection, options } = this.calendar;\n const minDate = new Date(domainCollection.min!);\n const maxDate = new Date(domainCollection.max!);\n\n if (date < minDate) {\n return this.loadNewDomains(\n this.calendar.createDomainCollection(date, minDate, false),\n ScrollDirection.SCROLL_BACKWARD,\n );\n }\n if (reset) {\n return this.loadNewDomains(\n this.calendar.createDomainCollection(date, options.options.range),\n minDate < date ?\n ScrollDirection.SCROLL_FORWARD :\n ScrollDirection.SCROLL_BACKWARD,\n );\n }\n\n if (date > maxDate) {\n return this.loadNewDomains(\n this.calendar.createDomainCollection(maxDate, date, false),\n ScrollDirection.SCROLL_FORWARD,\n );\n }\n\n return ScrollDirection.SCROLL_NONE;\n }\n\n #isDomainBoundaryReached(\n newDomainCollection: DomainCollection,\n minDate?: Timestamp,\n maxDate?: Timestamp,\n direction?: ScrollDirection,\n ): boolean {\n if (\n maxDate &&\n newDomainCollection.max! >= maxDate &&\n this.maxDomainReached &&\n direction === ScrollDirection.SCROLL_FORWARD\n ) {\n return true;\n }\n\n if (\n minDate &&\n newDomainCollection.min! <= minDate &&\n this.minDomainReached &&\n direction === ScrollDirection.SCROLL_BACKWARD\n ) {\n return true;\n }\n\n return false;\n }\n\n #setDomainsBoundaryReached(\n lowerBound: Timestamp,\n upperBound: Timestamp,\n min?: Timestamp,\n max?: Timestamp,\n ): void {\n if (min) {\n const reached = lowerBound <= min;\n this.calendar.eventEmitter.emit(\n reached ? 'minDateReached' : 'minDateNotReached',\n );\n this.minDomainReached = reached;\n }\n if (max) {\n const reached = upperBound >= max;\n this.calendar.eventEmitter.emit(\n reached ? 'maxDateReached' : 'maxDateNotReached',\n );\n this.maxDomainReached = reached;\n }\n }\n}\n","'use strict';\nvar $TypeError = TypeError;\nvar MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991\n\nmodule.exports = function (it) {\n if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');\n return it;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar isArray = require('../internals/is-array');\nvar isObject = require('../internals/is-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');\nvar createProperty = require('../internals/create-property');\nvar arraySpeciesCreate = require('../internals/array-species-create');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');\n\n// We can't use this feature detection in V8 since it causes\n// deoptimization and serious performance degradation\n// https://github.com/zloirock/core-js/issues/679\nvar IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {\n var array = [];\n array[IS_CONCAT_SPREADABLE] = false;\n return array.concat()[0] !== array;\n});\n\nvar isConcatSpreadable = function (O) {\n if (!isObject(O)) return false;\n var spreadable = O[IS_CONCAT_SPREADABLE];\n return spreadable !== undefined ? !!spreadable : isArray(O);\n};\n\nvar FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat');\n\n// `Array.prototype.concat` method\n// https://tc39.es/ecma262/#sec-array.prototype.concat\n// with adding support of @@isConcatSpreadable and @@species\n$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n concat: function concat(arg) {\n var O = toObject(this);\n var A = arraySpeciesCreate(O, 0);\n var n = 0;\n var i, k, length, len, E;\n for (i = -1, length = arguments.length; i < length; i++) {\n E = i === -1 ? O : arguments[i];\n if (isConcatSpreadable(E)) {\n len = lengthOfArrayLike(E);\n doesNotExceedSafeInteger(n + len);\n for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);\n } else {\n doesNotExceedSafeInteger(n + 1);\n createProperty(A, n++, E);\n }\n }\n A.length = n;\n return A;\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = function (METHOD_NAME, argument) {\n var method = [][METHOD_NAME];\n return !!method && fails(function () {\n // eslint-disable-next-line no-useless-call -- required for testing\n method.call(null, argument || function () { return 1; }, 1);\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar nativeJoin = uncurryThis([].join);\n\nvar ES3_STRINGS = IndexedObject !== Object;\nvar FORCED = ES3_STRINGS || !arrayMethodIsStrict('join', ',');\n\n// `Array.prototype.join` method\n// https://tc39.es/ecma262/#sec-array.prototype.join\n$({ target: 'Array', proto: true, forced: FORCED }, {\n join: function join(separator) {\n return nativeJoin(toIndexedObject(this), separator === undefined ? ',' : separator);\n }\n});\n","'use strict';\nvar create = require('../internals/object-create');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n index: create(null),\n first: undefined,\n last: undefined,\n size: 0\n });\n if (!DESCRIPTORS) that.size = 0;\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n var previous, index;\n // change existing entry\n if (entry) {\n entry.value = value;\n // create new entry\n } else {\n state.last = entry = {\n index: index = fastKey(key, true),\n key: key,\n value: value,\n previous: previous = state.last,\n next: undefined,\n removed: false\n };\n if (!state.first) state.first = entry;\n if (previous) previous.next = entry;\n if (DESCRIPTORS) state.size++;\n else that.size++;\n // add to index\n if (index !== 'F') state.index[index] = entry;\n } return that;\n };\n\n var getEntry = function (that, key) {\n var state = getInternalState(that);\n // fast case\n var index = fastKey(key);\n var entry;\n if (index !== 'F') return state.index[index];\n // frozen object case\n for (entry = state.first; entry; entry = entry.next) {\n if (entry.key === key) return entry;\n }\n };\n\n defineBuiltIns(Prototype, {\n // `{ Map, Set }.prototype.clear()` methods\n // https://tc39.es/ecma262/#sec-map.prototype.clear\n // https://tc39.es/ecma262/#sec-set.prototype.clear\n clear: function clear() {\n var that = this;\n var state = getInternalState(that);\n var data = state.index;\n var entry = state.first;\n while (entry) {\n entry.removed = true;\n if (entry.previous) entry.previous = entry.previous.next = undefined;\n delete data[entry.index];\n entry = entry.next;\n }\n state.first = state.last = undefined;\n if (DESCRIPTORS) state.size = 0;\n else that.size = 0;\n },\n // `{ Map, Set }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.delete\n // https://tc39.es/ecma262/#sec-set.prototype.delete\n 'delete': function (key) {\n var that = this;\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n if (entry) {\n var next = entry.next;\n var prev = entry.previous;\n delete state.index[entry.index];\n entry.removed = true;\n if (prev) prev.next = next;\n if (next) next.previous = prev;\n if (state.first === entry) state.first = next;\n if (state.last === entry) state.last = prev;\n if (DESCRIPTORS) state.size--;\n else that.size--;\n } return !!entry;\n },\n // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.foreach\n // https://tc39.es/ecma262/#sec-set.prototype.foreach\n forEach: function forEach(callbackfn /* , that = undefined */) {\n var state = getInternalState(this);\n var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n var entry;\n while (entry = entry ? entry.next : state.first) {\n boundFunction(entry.value, entry.key, this);\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n }\n },\n // `{ Map, Set}.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.has\n // https://tc39.es/ecma262/#sec-set.prototype.has\n has: function has(key) {\n return !!getEntry(this, key);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `Map.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-map.prototype.get\n get: function get(key) {\n var entry = getEntry(this, key);\n return entry && entry.value;\n },\n // `Map.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-map.prototype.set\n set: function set(key, value) {\n return define(this, key === 0 ? 0 : key, value);\n }\n } : {\n // `Set.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-set.prototype.add\n add: function add(value) {\n return define(this, value = value === 0 ? 0 : value, value);\n }\n });\n if (DESCRIPTORS) defineBuiltInAccessor(Prototype, 'size', {\n configurable: true,\n get: function () {\n return getInternalState(this).size;\n }\n });\n return Constructor;\n },\n setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {\n var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods\n // https://tc39.es/ecma262/#sec-map.prototype.entries\n // https://tc39.es/ecma262/#sec-map.prototype.keys\n // https://tc39.es/ecma262/#sec-map.prototype.values\n // https://tc39.es/ecma262/#sec-map.prototype-@@iterator\n // https://tc39.es/ecma262/#sec-set.prototype.entries\n // https://tc39.es/ecma262/#sec-set.prototype.keys\n // https://tc39.es/ecma262/#sec-set.prototype.values\n // https://tc39.es/ecma262/#sec-set.prototype-@@iterator\n defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {\n setInternalState(this, {\n type: ITERATOR_NAME,\n target: iterated,\n state: getInternalCollectionState(iterated),\n kind: kind,\n last: undefined\n });\n }, function () {\n var state = getInternalIteratorState(this);\n var kind = state.kind;\n var entry = state.last;\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n // get next entry\n if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n // or finish the iteration\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n // return step by kind\n if (kind === 'keys') return createIterResultObject(entry.key, false);\n if (kind === 'values') return createIterResultObject(entry.value, false);\n return createIterResultObject([entry.key, entry.value], false);\n }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n // `{ Map, Set }.prototype[@@species]` accessors\n // https://tc39.es/ecma262/#sec-get-map-@@species\n // https://tc39.es/ecma262/#sec-get-set-@@species\n setSpecies(CONSTRUCTOR_NAME);\n }\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.es/ecma262/#sec-map-objects\ncollection('Map', function (init) {\n return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","'use strict';\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (O, P) {\n if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));\n};\n","'use strict';\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar floor = Math.floor;\n\nvar mergeSort = function (array, comparefn) {\n var length = array.length;\n var middle = floor(length / 2);\n return length < 8 ? insertionSort(array, comparefn) : merge(\n array,\n mergeSort(arraySlice(array, 0, middle), comparefn),\n mergeSort(arraySlice(array, middle), comparefn),\n comparefn\n );\n};\n\nvar insertionSort = function (array, comparefn) {\n var length = array.length;\n var i = 1;\n var element, j;\n\n while (i < length) {\n j = i;\n element = array[i];\n while (j && comparefn(array[j - 1], element) > 0) {\n array[j] = array[--j];\n }\n if (j !== i++) array[j] = element;\n } return array;\n};\n\nvar merge = function (array, left, right, comparefn) {\n var llength = left.length;\n var rlength = right.length;\n var lindex = 0;\n var rindex = 0;\n\n while (lindex < llength || rindex < rlength) {\n array[lindex + rindex] = (lindex < llength && rindex < rlength)\n ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]\n : lindex < llength ? left[lindex++] : right[rindex++];\n } return array;\n};\n\nmodule.exports = mergeSort;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nvar firefox = userAgent.match(/firefox\\/(\\d+)/i);\n\nmodule.exports = !!firefox && +firefox[1];\n","'use strict';\nvar UA = require('../internals/engine-user-agent');\n\nmodule.exports = /MSIE|Trident/.test(UA);\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nvar webkit = userAgent.match(/AppleWebKit\\/(\\d+)\\./);\n\nmodule.exports = !!webkit && +webkit[1];\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar deletePropertyOrThrow = require('../internals/delete-property-or-throw');\nvar toString = require('../internals/to-string');\nvar fails = require('../internals/fails');\nvar internalSort = require('../internals/array-sort');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\nvar FF = require('../internals/engine-ff-version');\nvar IE_OR_EDGE = require('../internals/engine-is-ie-or-edge');\nvar V8 = require('../internals/engine-v8-version');\nvar WEBKIT = require('../internals/engine-webkit-version');\n\nvar test = [];\nvar nativeSort = uncurryThis(test.sort);\nvar push = uncurryThis(test.push);\n\n// IE8-\nvar FAILS_ON_UNDEFINED = fails(function () {\n test.sort(undefined);\n});\n// V8 bug\nvar FAILS_ON_NULL = fails(function () {\n test.sort(null);\n});\n// Old WebKit\nvar STRICT_METHOD = arrayMethodIsStrict('sort');\n\nvar STABLE_SORT = !fails(function () {\n // feature detection can be too slow, so check engines versions\n if (V8) return V8 < 70;\n if (FF && FF > 3) return;\n if (IE_OR_EDGE) return true;\n if (WEBKIT) return WEBKIT < 603;\n\n var result = '';\n var code, chr, value, index;\n\n // generate an array with more 512 elements (Chakra and old V8 fails only in this case)\n for (code = 65; code < 76; code++) {\n chr = String.fromCharCode(code);\n\n switch (code) {\n case 66: case 69: case 70: case 72: value = 3; break;\n case 68: case 71: value = 4; break;\n default: value = 2;\n }\n\n for (index = 0; index < 47; index++) {\n test.push({ k: chr + index, v: value });\n }\n }\n\n test.sort(function (a, b) { return b.v - a.v; });\n\n for (index = 0; index < test.length; index++) {\n chr = test[index].k.charAt(0);\n if (result.charAt(result.length - 1) !== chr) result += chr;\n }\n\n return result !== 'DGBEFHACIJK';\n});\n\nvar FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;\n\nvar getSortCompare = function (comparefn) {\n return function (x, y) {\n if (y === undefined) return -1;\n if (x === undefined) return 1;\n if (comparefn !== undefined) return +comparefn(x, y) || 0;\n return toString(x) > toString(y) ? 1 : -1;\n };\n};\n\n// `Array.prototype.sort` method\n// https://tc39.es/ecma262/#sec-array.prototype.sort\n$({ target: 'Array', proto: true, forced: FORCED }, {\n sort: function sort(comparefn) {\n if (comparefn !== undefined) aCallable(comparefn);\n\n var array = toObject(this);\n\n if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn);\n\n var items = [];\n var arrayLength = lengthOfArrayLike(array);\n var itemsLength, index;\n\n for (index = 0; index < arrayLength; index++) {\n if (index in array) push(items, array[index]);\n }\n\n internalSort(items, getSortCompare(comparefn));\n\n itemsLength = lengthOfArrayLike(items);\n index = 0;\n\n while (index < itemsLength) array[index] = items[index++];\n while (index < arrayLength) deletePropertyOrThrow(array, index++);\n\n return array;\n }\n});\n","'use strict';\nvar $forEach = require('../internals/array-iteration').forEach;\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar STRICT_METHOD = arrayMethodIsStrict('forEach');\n\n// `Array.prototype.forEach` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.foreach\nmodule.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {\n return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n// eslint-disable-next-line es/no-array-prototype-foreach -- safe\n} : [].forEach;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar forEach = require('../internals/array-for-each');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar handlePrototype = function (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {\n createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);\n } catch (error) {\n CollectionPrototype.forEach = forEach;\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n if (DOMIterables[COLLECTION_NAME]) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype);\n }\n}\n\nhandlePrototype(DOMTokenListPrototype);\n","import { Position } from '../constant';\nimport type { Padding } from '../options/Options';\n\nexport function isHorizontal(position: string): boolean {\n return position === 'left' || position === 'right';\n}\n\nexport function isVertical(position: string): boolean {\n return position === 'top' || position === 'bottom';\n}\n\nexport function horizontalPadding(padding: Padding): number {\n return padding[Position.LEFT] + padding[Position.RIGHT];\n}\n\nexport function verticalPadding(padding: Padding): number {\n return padding[Position.TOP] + padding[Position.BOTTOM];\n}\n","import { ScrollDirection } from '../constant';\nimport { horizontalPadding, verticalPadding } from '../helpers/PositionHelper';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type DomainPainter from './DomainPainter';\nimport type DomainCollection from '../calendar/DomainCollection';\nimport type { SubDomain, Dimensions, Timestamp } from '../index';\n\ntype SubDomainWithCoordinates = Required & {\n pre_x: number;\n pre_y: number;\n width: number;\n height: number;\n inner_width: number;\n inner_height: number;\n};\n\nexport default class DomainCoordinates {\n calendar: CalHeatmap;\n\n domainPainter: DomainPainter;\n\n collection: Map;\n\n scrollDirection: ScrollDirection;\n\n constructor(calendar: CalHeatmap, domainPainter: DomainPainter) {\n this.calendar = calendar;\n this.domainPainter = domainPainter;\n this.collection = new Map();\n this.scrollDirection = ScrollDirection.SCROLL_FORWARD;\n }\n\n get(domainKey: Timestamp): SubDomainWithCoordinates | undefined {\n return this.collection.get(domainKey);\n }\n\n update(collection: DomainCollection, scrollDirection: ScrollDirection) {\n const { verticalOrientation, domain } = this.calendar.options.options;\n\n this.scrollDirection = scrollDirection;\n const dimensions: Dimensions = {\n width: 0,\n height: 0,\n };\n let exitingTotal = 0;\n let scrollFactor =\n scrollDirection === ScrollDirection.SCROLL_FORWARD ? -1 : 1;\n const { keys } = collection;\n if (this.calendar.options.options.domain.sort === 'desc') {\n keys.reverse();\n scrollFactor *= -1;\n }\n\n collection.yankedDomains.forEach((domainKey: Timestamp) => {\n exitingTotal +=\n this.collection.get(domainKey)![\n verticalOrientation ? 'height' : 'width'\n ];\n });\n collection.yankedDomains.forEach((domainKey: Timestamp) => {\n const coor = this.collection.get(domainKey)!;\n this.collection.set(domainKey, {\n ...coor,\n x: verticalOrientation ? coor.x : coor.x + exitingTotal * scrollFactor,\n y: verticalOrientation ? coor.y + exitingTotal * scrollFactor : coor.y,\n });\n });\n\n keys.forEach((domainKey: Timestamp) => {\n const w = this.#getWidth(domainKey);\n const h = this.#getHeight(domainKey);\n if (verticalOrientation) {\n dimensions.height += h;\n dimensions.width = Math.max(w, dimensions.width);\n } else {\n dimensions.width += w;\n dimensions.height = Math.max(h, dimensions.height);\n }\n\n const x = dimensions.width - w;\n const y = dimensions.height - h;\n\n this.collection.set(domainKey, {\n ...this.collection.get(domainKey)!,\n x: verticalOrientation ? 0 : x,\n y: verticalOrientation ? y : 0,\n pre_x: verticalOrientation ? x : x - exitingTotal * scrollFactor,\n pre_y: verticalOrientation ? y - exitingTotal * scrollFactor : y,\n width: w,\n height: h,\n inner_width: w - (verticalOrientation ? 0 : domain.gutter),\n inner_height: h - (!verticalOrientation ? 0 : domain.gutter),\n });\n });\n\n return dimensions;\n }\n\n /**\n * Return the full width of the domain block\n * @param {number} d Domain start timestamp\n * @return {number} The full width of the domain,\n * including all padding and gutter\n * Used to compute the x position of the domains on the x axis\n */\n #getWidth(d: Timestamp): number {\n const {\n domain, subDomain, x, verticalOrientation,\n } =\n this.calendar.options.options;\n const columnsCount = this.calendar.templateCollection\n .get(subDomain.type)!\n .columnsCount(d);\n\n const subDomainWidth =\n (subDomain.width + subDomain.gutter) * columnsCount - subDomain.gutter;\n\n return (\n horizontalPadding(domain.padding) +\n x.domainHorizontalLabelWidth +\n (verticalOrientation ? 0 : domain.gutter) +\n subDomainWidth\n );\n }\n\n /**\n * Return the full height of the domain block\n * @param {number} d Domain start timestamp\n * @return {number} The full height of the domain,\n * including all paddings and gutter.\n * Used to compute the y position of the domains on the y axis\n */\n #getHeight(d: Timestamp): number {\n const {\n domain, subDomain, x, verticalOrientation,\n } =\n this.calendar.options.options;\n const rowsCount = this.calendar.templateCollection\n .get(subDomain.type)!\n .rowsCount(d);\n\n const subDomainHeight =\n (subDomain.height + subDomain.gutter) * rowsCount - subDomain.gutter;\n\n return (\n verticalPadding(domain.padding) +\n subDomainHeight +\n (verticalOrientation ? domain.gutter : 0) +\n x.domainVerticalLabelHeight\n );\n }\n}\n","import DomainCoordinates from './DomainCoordinates';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { ScrollDirection } from '../constant';\nimport type { Dimensions, Timestamp } from '../index';\n\nconst DEFAULT_SELECTOR = '.ch-domain';\n\nexport default class DomainPainter {\n calendar: CalHeatmap;\n\n coordinates: DomainCoordinates;\n\n root: any;\n\n dimensions: Dimensions;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.coordinates = new DomainCoordinates(calendar, this);\n this.root = null;\n\n // Dimensions of the internal area containing all the domains\n // Excluding all surrounding margins\n this.dimensions = {\n width: 0,\n height: 0,\n };\n }\n\n paint(scrollDirection: ScrollDirection, rootNode: any): Promise[] {\n const { animationDuration } = this.calendar.options.options;\n const t = rootNode.transition().duration(animationDuration);\n const coor = this.coordinates;\n\n this.dimensions = coor.update(\n this.calendar.domainCollection,\n scrollDirection,\n );\n\n const promises: Promise[] = [];\n\n this.root = rootNode\n .selectAll(DEFAULT_SELECTOR)\n .data(this.calendar.domainCollection.keys, (d: Timestamp) => d)\n .join(\n (enter: any) => enter\n .append('svg')\n .attr('x', (d: Timestamp) => coor.get(d)!.pre_x)\n .attr('y', (d: Timestamp) => coor.get(d)!.pre_y)\n .attr('width', (d: Timestamp) => coor.get(d)!.inner_width)\n .attr('height', (d: Timestamp) => coor.get(d)!.inner_height)\n .attr('class', (d: Timestamp) => this.#getClassName(d))\n .call((enterSelection: any) => enterSelection\n .append('rect')\n .attr('width', (d: Timestamp) => coor.get(d)!.inner_width)\n .attr('height', (d: Timestamp) => coor.get(d)!.inner_height)\n .attr('class', `${DEFAULT_SELECTOR.slice(1)}-bg`))\n .call((enterSelection: any) => promises.push(\n enterSelection\n .transition(t)\n .attr('x', (d: Timestamp) => coor.get(d)!.x)\n .attr('y', (d: Timestamp) => coor.get(d)!.y)\n .end(),\n )),\n (update: any) => update\n .call((updateSelection: any) => promises.push(\n updateSelection\n .transition(t)\n .attr('x', (d: Timestamp) => coor.get(d)!.x)\n .attr('y', (d: Timestamp) => coor.get(d)!.y)\n .attr('width', (d: Timestamp) => coor.get(d)!.inner_width)\n .attr('height', (d: Timestamp) => coor.get(d)!.inner_height)\n .end(),\n ))\n .call((updateSelection: any) => promises.push(\n updateSelection\n .selectAll(`${DEFAULT_SELECTOR}-bg`)\n .transition(t)\n .attr('width', (d: Timestamp) => coor.get(d)!.inner_width)\n .attr('height', (d: Timestamp) => coor.get(d)!.inner_height)\n .end(),\n )),\n (exit: any) => exit.call((exitSelection: any) => promises.push(\n exitSelection\n .transition(t)\n .attr('x', (d: Timestamp) => coor.get(d)!.x)\n .attr('y', (d: Timestamp) => coor.get(d)!.y)\n .remove()\n .end(),\n )),\n );\n\n return promises;\n }\n\n #getClassName(d: Timestamp): string {\n let classname = DEFAULT_SELECTOR.slice(1);\n const helper = this.calendar.dateHelper.date(d);\n\n switch (this.calendar.options.options.domain.type) {\n case 'hour':\n classname += ` h_${helper.hour()}`;\n break;\n case 'day':\n classname += ` d_${helper.date()} dy_${helper.format('d') + 1}`;\n break;\n case 'week':\n classname += ` w_${helper.week()}`;\n break;\n case 'month':\n classname += ` m_${helper.month() + 1}`;\n break;\n case 'year':\n classname += ` y_${helper.year()}`;\n break;\n default:\n }\n return classname;\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar $includes = require('../internals/array-includes').includes;\nvar fails = require('../internals/fails');\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// FF99+ bug\nvar BROKEN_ON_SPARSE = fails(function () {\n // eslint-disable-next-line es/no-array-prototype-includes -- detection\n return !Array(1).includes();\n});\n\n// `Array.prototype.includes` method\n// https://tc39.es/ecma262/#sec-array.prototype.includes\n$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {\n includes: function includes(el /* , fromIndex = 0 */) {\n return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('includes');\n","'use strict';\nvar $ = require('../internals/export');\nvar $filter = require('../internals/array-iteration').filter;\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter');\n\n// `Array.prototype.filter` method\n// https://tc39.es/ecma262/#sec-array.prototype.filter\n// with adding support of @@species\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n filter: function filter(callbackfn /* , thisArg */) {\n return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar iteratorClose = require('../internals/iterator-close');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n try {\n return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar toObject = require('../internals/to-object');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar isConstructor = require('../internals/is-constructor');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $Array = Array;\n\n// `Array.from` method implementation\n// https://tc39.es/ecma262/#sec-array.from\nmodule.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n var O = toObject(arrayLike);\n var IS_CONSTRUCTOR = isConstructor(this);\n var argumentsLength = arguments.length;\n var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n var mapping = mapfn !== undefined;\n if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);\n var iteratorMethod = getIteratorMethod(O);\n var index = 0;\n var length, result, step, iterator, next, value;\n // if the target is not iterable or it's an array with the default iterator - use a simple case\n if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) {\n iterator = getIterator(O, iteratorMethod);\n next = iterator.next;\n result = IS_CONSTRUCTOR ? new this() : [];\n for (;!(step = call(next, iterator)).done; index++) {\n value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;\n createProperty(result, index, value);\n }\n } else {\n length = lengthOfArrayLike(O);\n result = IS_CONSTRUCTOR ? new this(length) : $Array(length);\n for (;length > index; index++) {\n value = mapping ? mapfn(O[index], index) : O[index];\n createProperty(result, index, value);\n }\n }\n result.length = index;\n return result;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar from = require('../internals/array-from');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\n\nvar INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {\n // eslint-disable-next-line es/no-array-from -- required for testing\n Array.from(iterable);\n});\n\n// `Array.from` method\n// https://tc39.es/ecma262/#sec-array.from\n$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {\n from: from\n});\n","import castArray from 'lodash-es/castArray';\n\nimport type { SubDomain } from '../index';\nimport type {\n DataOptions,\n DataGroupType,\n DataRecord,\n} from '../options/Options';\nimport { DomainType, Timestamp } from '../index';\nimport type DateHelper from '../helpers/DateHelper';\n\nexport const DOMAIN_FORMAT: Record = {\n year: 'YYYY',\n month: 'MMMM',\n week: 'wo [week] YYYY',\n xDay: 'Do MMM',\n ghDay: 'Do MMM',\n day: 'Do MMM',\n hour: 'HH:00',\n minute: 'HH:mm',\n};\n\ntype GroupedRecords = Map;\ntype ValueType = string | number | null;\n\nexport default class DomainCollection {\n collection: Map;\n\n dateHelper: DateHelper;\n\n min: Timestamp;\n\n max: Timestamp;\n\n keys: Timestamp[];\n\n yankedDomains: Timestamp[];\n\n constructor(\n dateHelper: DateHelper,\n interval?: DomainType,\n start?: Date | Timestamp,\n range?: Date | Timestamp,\n excludeEnd: boolean = false,\n ) {\n this.collection = new Map();\n this.dateHelper = dateHelper;\n\n if (interval && start && range) {\n const ts = this.dateHelper\n .intervals(interval, start, range, excludeEnd)\n .map((d: Timestamp) => castArray(d));\n\n // @ts-ignore\n this.collection = new Map(ts);\n }\n\n this.min = 0;\n this.max = 0;\n this.keys = [];\n this.yankedDomains = [];\n\n if (this.collection.size > 0) {\n this.#refreshKeys();\n }\n }\n\n has(key: Timestamp): boolean {\n return this.collection.has(key);\n }\n\n get(key: Timestamp) {\n return this.collection.get(key);\n }\n\n forEach(callback: any) {\n return this.collection.forEach(callback);\n }\n\n at(index: number): Timestamp {\n return this.keys[index];\n }\n\n clamp(minDate?: Timestamp, maxDate?: Timestamp): DomainCollection {\n if (minDate && this.min! < minDate) {\n this.keys\n .filter((key) => key < minDate)\n .forEach((d) => this.collection.delete(d));\n }\n\n if (maxDate && this.max! > maxDate) {\n this.keys\n .filter((key) => key > maxDate)\n .forEach((d) => this.collection.delete(d));\n }\n\n this.#refreshKeys();\n\n return this;\n }\n\n merge(\n newCollection: DomainCollection,\n limit: number,\n createValueCallback: Function,\n ): void {\n this.yankedDomains = [];\n\n newCollection.keys.forEach((domainKey, index) => {\n if (this.has(domainKey)) {\n return;\n }\n\n if (this.collection.size >= limit) {\n let keyToRemove = this.max;\n\n if (domainKey > this.max!) {\n keyToRemove = this.min;\n }\n\n if (keyToRemove && this.collection.delete(keyToRemove)) {\n this.yankedDomains.push(keyToRemove);\n }\n }\n this.collection.set(domainKey, createValueCallback(domainKey, index));\n this.#refreshKeys();\n });\n this.yankedDomains = this.yankedDomains.sort((a, b) => a - b);\n }\n\n slice(limit: number = 0, fromBeginning: boolean = true): DomainCollection {\n if (this.keys.length > limit) {\n const keysToDelete = fromBeginning ?\n this.keys.slice(0, -limit) :\n this.keys.slice(limit);\n\n keysToDelete.forEach((key) => {\n this.collection.delete(key);\n });\n\n this.#refreshKeys();\n }\n\n return this;\n }\n\n fill(\n data: DataRecord[],\n {\n x,\n y,\n groupY,\n defaultValue,\n }: {\n x: DataOptions['x'];\n y: DataOptions['y'];\n groupY: DataOptions['groupY'];\n defaultValue: DataOptions['defaultValue'];\n },\n subDomainKeyExtractor: Function,\n ): void {\n const groupedRecords: GroupedRecords = this.groupRecords(\n data,\n x,\n subDomainKeyExtractor,\n );\n\n this.keys.forEach((domainKey) => {\n const records = groupedRecords.get(domainKey) || {};\n this.#setSubDomainValues(domainKey, records, y, groupY, defaultValue);\n });\n }\n\n #setSubDomainValues(\n domainKey: Timestamp,\n records: { [key: string]: DataRecord[] },\n y: DataOptions['y'],\n groupY: DataOptions['groupY'],\n defaultValue: DataOptions['defaultValue'],\n ): void {\n this.get(domainKey)!.forEach((subDomain: SubDomain, index: number) => {\n let value: ValueType = defaultValue;\n if (records.hasOwnProperty(subDomain.t)) {\n value = this.groupValues(\n this.#extractValues(records[subDomain.t], y),\n groupY,\n );\n }\n\n this.get(domainKey)![index].v = value;\n });\n }\n\n groupRecords(\n data: DataRecord[],\n x: DataOptions['x'],\n subDomainKeyExtractor: Function,\n ): GroupedRecords {\n const results: GroupedRecords = new Map();\n const validSubDomainTimestamp: Map = new Map();\n this.keys.forEach((domainKey) => {\n this.get(domainKey)!.forEach((subDomain: SubDomain) => {\n validSubDomainTimestamp.set(subDomain.t, domainKey);\n });\n });\n\n data.forEach((d) => {\n const timestamp = this.extractTimestamp(d, x, subDomainKeyExtractor);\n\n if (validSubDomainTimestamp.has(timestamp)) {\n const domainKey = validSubDomainTimestamp.get(timestamp)!;\n const records = results.get(domainKey) || {};\n records[timestamp] ||= [];\n records[timestamp].push(d);\n\n results.set(domainKey, records);\n }\n });\n\n return results;\n }\n\n // eslint-disable-next-line class-methods-use-this\n #extractValues(data: DataRecord[], y: string | Function): ValueType[] {\n return data.map((d): ValueType => (typeof y === 'function' ? y(d) : d[y]));\n }\n\n // eslint-disable-next-line class-methods-use-this\n groupValues(\n values: ValueType[],\n groupFn: DataGroupType | ((values: ValueType[]) => ValueType),\n ): ValueType {\n const cleanedValues = values.filter((n) => n !== null);\n\n if (typeof groupFn === 'string') {\n if (cleanedValues.every((n) => typeof n === 'number')) {\n switch (groupFn) {\n case 'sum':\n return (cleanedValues as number[]).reduce((a, b) => a + b, 0);\n case 'count':\n return cleanedValues.length;\n case 'min':\n return Math.min(...(cleanedValues as number[])) || null;\n case 'max':\n return Math.max(...(cleanedValues as number[])) || null;\n case 'average':\n return cleanedValues.length > 0 ?\n (cleanedValues as number[]).reduce((a, b) => a + b, 0) /\n cleanedValues.length :\n null;\n default:\n return null;\n }\n }\n\n switch (groupFn) {\n case 'count':\n return cleanedValues.length;\n default:\n return null;\n }\n } else if (typeof groupFn === 'function') {\n return groupFn(cleanedValues);\n }\n\n return null;\n }\n\n // eslint-disable-next-line class-methods-use-this\n extractTimestamp(\n datum: DataRecord,\n x: string | Function,\n extractorFn: Function,\n ): Timestamp {\n let timestamp: string | Timestamp =\n typeof x === 'function' ? x(datum) : datum[x];\n\n if (typeof timestamp === 'string') {\n timestamp = +new Date(timestamp);\n }\n\n return extractorFn(timestamp);\n }\n\n #refreshKeys(): Timestamp[] {\n this.keys = Array.from(this.collection.keys())\n .map((d: any) => parseInt(d, 10))\n .sort((a, b) => a - b);\n\n const { keys } = this;\n // eslint-disable-next-line prefer-destructuring\n this.min = keys[0];\n this.max = keys[keys.length - 1];\n\n return this.keys;\n }\n}\n","import { Position } from '../constant';\nimport {\n isVertical,\n verticalPadding,\n horizontalPadding,\n} from '../helpers/PositionHelper';\nimport { DOMAIN_FORMAT } from '../calendar/DomainCollection';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { Timestamp } from '../index';\n\nconst DEFAULT_SELECTOR = '.ch-domain-text';\n\nexport default class DomainLabelPainter {\n calendar: CalHeatmap;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n }\n\n paint(root: any): void {\n const { label, type } = this.calendar.options.options.domain;\n const { dateHelper } = this.calendar;\n let format = label.text;\n if (format === null || format === '') {\n return;\n }\n\n if (typeof format === 'undefined') {\n format = DOMAIN_FORMAT[type];\n }\n\n root\n .selectAll(DEFAULT_SELECTOR)\n .data(\n (d: Timestamp) => [d],\n (d: Timestamp) => d,\n )\n .join(\n (enter: any) => enter\n .append('text')\n .attr('class', DEFAULT_SELECTOR.slice(1))\n .attr('x', (d: Timestamp) => this.#getX(d))\n .attr('y', (d: Timestamp) => this.#getY(d))\n .attr('text-anchor', label.textAlign)\n .attr('dominant-baseline', () => this.#textVerticalAlign())\n .text((d: Timestamp, i: number, nodes: any[]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n dateHelper.format(d, format!, nodes[i]))\n .call((selection: any) => this.#domainRotate(selection)),\n (update: any) => {\n update\n .attr('x', (d: Timestamp) => this.#getX(d))\n .attr('y', (d: Timestamp) => this.#getY(d))\n .attr('text-anchor', label.textAlign)\n .attr('dominant-baseline', () => this.#textVerticalAlign())\n .text((d: Timestamp, i: number, nodes: any[]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n dateHelper.format(d, format!, nodes[i]))\n .call((selection: any) => this.#domainRotate(selection));\n },\n );\n }\n\n #textVerticalAlign(): string {\n const { position, rotate } = this.calendar.options.options.domain.label;\n\n if (isVertical(position)) {\n return 'middle';\n }\n\n if (\n (rotate === 'left' && position === 'left') ||\n (rotate === 'right' && position === 'right')\n ) {\n return 'bottom';\n }\n\n return 'hanging';\n }\n\n #getX(d: Timestamp): number {\n const {\n padding,\n label: { position, textAlign, offset },\n } = this.calendar.options.options.domain;\n const { domainHorizontalLabelWidth } = this.calendar.options.options.x;\n\n let x = padding[Position.LEFT];\n\n if (position === 'right') {\n x += this.#getDomainInsideWidth(d);\n }\n\n if (textAlign === 'middle') {\n if (['top', 'bottom'].includes(position)) {\n x += this.#getDomainInsideWidth(d) / 2;\n } else {\n x += domainHorizontalLabelWidth / 2;\n }\n }\n\n if (textAlign === 'end') {\n if (isVertical(position)) {\n x += this.#getDomainInsideWidth(d);\n } else {\n x += domainHorizontalLabelWidth;\n }\n }\n\n return x + offset.x;\n }\n\n #getY(d: Timestamp): number {\n const {\n domain: {\n label: { position, offset },\n padding,\n },\n x,\n } = this.calendar.options.options;\n\n let y = padding[Position.TOP] + x.domainVerticalLabelHeight / 2;\n\n if (position === 'bottom') {\n y += this.#getDomainInsideHeight(d);\n }\n\n return y + offset.y;\n }\n\n #getDomainInsideWidth(d: Timestamp): number {\n const {\n domain: { padding },\n x: { domainHorizontalLabelWidth },\n } = this.calendar.options.options;\n const { coordinates } =\n this.calendar.calendarPainter.domainsContainerPainter.domainPainter;\n\n return (\n coordinates.get(d)!.inner_width -\n domainHorizontalLabelWidth -\n horizontalPadding(padding)\n );\n }\n\n #getDomainInsideHeight(d: Timestamp): number {\n const {\n x: { domainVerticalLabelHeight },\n domain: { padding },\n } = this.calendar.options.options;\n const { coordinates } =\n this.calendar.calendarPainter.domainsContainerPainter.domainPainter;\n\n return (\n coordinates.get(d)!.inner_height -\n domainVerticalLabelHeight -\n verticalPadding(padding)\n );\n }\n\n #domainRotate(selection: any) {\n const {\n domain: {\n label: { rotate, textAlign, position },\n },\n x,\n } = this.calendar.options.options;\n const labelWidth = x.domainHorizontalLabelWidth;\n\n switch (rotate) {\n // Rotating the text clockwise\n case 'right':\n selection.attr('transform', (d: Timestamp) => {\n const domainWidth = this.#getDomainInsideWidth(d);\n const domainHeight = this.#getDomainInsideHeight(d);\n const s = [\n `rotate(90, ${position === 'right' ? domainWidth : labelWidth}, 0)`,\n ];\n\n switch (position) {\n case 'right':\n if (textAlign === 'middle') {\n s.push(`translate(${domainHeight / 2 - labelWidth / 2})`);\n } else if (textAlign === 'end') {\n s.push(`translate(${domainHeight - labelWidth})`);\n }\n break;\n case 'left':\n if (textAlign === 'start') {\n s.push(`translate(${labelWidth})`);\n } else if (textAlign === 'middle') {\n s.push(`translate(${labelWidth / 2 + domainHeight / 2})`);\n } else if (textAlign === 'end') {\n s.push(`translate(${domainHeight})`);\n }\n break;\n default:\n }\n\n return s.join(',');\n });\n break;\n // Rotating the text anticlockwise\n case 'left':\n selection.attr('transform', (d: Timestamp) => {\n const domainWidth = this.#getDomainInsideWidth(d);\n const domainHeight = this.#getDomainInsideHeight(d);\n const s = [\n `rotate(270, ${\n position === 'right' ? domainWidth : labelWidth\n }, 0)`,\n ];\n\n switch (position) {\n case 'right':\n if (textAlign === 'start') {\n s.push(`translate(-${domainHeight})`);\n } else if (textAlign === 'middle') {\n s.push(`translate(-${domainHeight / 2 + labelWidth / 2})`);\n } else if (textAlign === 'end') {\n s.push(`translate(-${labelWidth})`);\n }\n break;\n case 'left':\n if (textAlign === 'start') {\n s.push(`translate(${labelWidth - domainHeight})`);\n } else if (textAlign === 'middle') {\n s.push(`translate(${labelWidth / 2 - domainHeight / 2})`);\n }\n break;\n default:\n }\n\n return s.join(',');\n });\n break;\n default:\n }\n }\n}\n","'use strict';\n// a string of all valid unicode whitespaces\nmodule.exports = '\\u0009\\u000A\\u000B\\u000C\\u000D\\u0020\\u00A0\\u1680\\u2000\\u2001\\u2002' +\n '\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\nvar whitespaces = require('../internals/whitespaces');\n\nvar replace = uncurryThis(''.replace);\nvar ltrim = RegExp('^[' + whitespaces + ']+');\nvar rtrim = RegExp('(^|[^' + whitespaces + '])[' + whitespaces + ']+$');\n\n// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation\nvar createMethod = function (TYPE) {\n return function ($this) {\n var string = toString(requireObjectCoercible($this));\n if (TYPE & 1) string = replace(string, ltrim, '');\n if (TYPE & 2) string = replace(string, rtrim, '$1');\n return string;\n };\n};\n\nmodule.exports = {\n // `String.prototype.{ trimLeft, trimStart }` methods\n // https://tc39.es/ecma262/#sec-string.prototype.trimstart\n start: createMethod(1),\n // `String.prototype.{ trimRight, trimEnd }` methods\n // https://tc39.es/ecma262/#sec-string.prototype.trimend\n end: createMethod(2),\n // `String.prototype.trim` method\n // https://tc39.es/ecma262/#sec-string.prototype.trim\n trim: createMethod(3)\n};\n","'use strict';\nvar PROPER_FUNCTION_NAME = require('../internals/function-name').PROPER;\nvar fails = require('../internals/fails');\nvar whitespaces = require('../internals/whitespaces');\n\nvar non = '\\u200B\\u0085\\u180E';\n\n// check that a method works with the correct list\n// of whitespaces and has a correct name\nmodule.exports = function (METHOD_NAME) {\n return fails(function () {\n return !!whitespaces[METHOD_NAME]()\n || non[METHOD_NAME]() !== non\n || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME);\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $trim = require('../internals/string-trim').trim;\nvar forcedStringTrimMethod = require('../internals/string-trim-forced');\n\n// `String.prototype.trim` method\n// https://tc39.es/ecma262/#sec-string.prototype.trim\n$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {\n trim: function trim() {\n return $trim(this);\n }\n});\n","import { Position } from '../constant';\nimport type CalHeatmap from '../CalHeatmap';\nimport type { Timestamp, SubDomain } from '../index';\n\nexport const DEFAULT_SELECTOR = '.ch-subdomain';\nconst HIGHLIGHT_CLASSNAME = 'highlight';\n\nexport default class SubDomainPainter {\n calendar: CalHeatmap;\n\n root: any;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.root = null;\n }\n\n paint(root: any): void {\n this.root = root || this.root;\n const containerClassname = `${DEFAULT_SELECTOR}-container`;\n\n const subDomainSvgGroup = this.root\n .selectAll(containerClassname)\n .data(\n (d: Timestamp) => [d],\n (d: Timestamp) => d,\n )\n .join(\n (enter: any) => enter\n .append('svg')\n .call((selection: any) => this.#setPositions(selection))\n .attr('class', containerClassname.slice(1)),\n\n (update: any) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n update.call((selection: any) => this.#setPositions(selection)),\n );\n\n const {\n subDomain: {\n radius, width, height, sort,\n },\n } = this.calendar.options.options;\n const evt = this.calendar.eventEmitter;\n\n subDomainSvgGroup\n .selectAll('g')\n .data((d: Timestamp) => {\n const subDomainsCollection: SubDomain[] =\n this.calendar.domainCollection.get(d)!;\n if (sort === 'desc') {\n const max = Math.max(\n ...subDomainsCollection.map((s: SubDomain) => s.x),\n );\n subDomainsCollection.forEach((s: SubDomain, i: number) => {\n subDomainsCollection[i].x = Math.abs(s.x - max);\n });\n }\n\n return subDomainsCollection;\n })\n .join(\n (enter: any) => enter\n .append('g')\n .call((selection: any) => selection\n .insert('rect')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-bg`))\n .attr('width', width)\n .attr('height', height)\n .attr('x', (d: SubDomain) => this.#getX(d))\n .attr('y', (d: SubDomain) => this.#getY(d))\n .on('click', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('click', ev, d.t, d.v))\n .on('mouseover', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('mouseover', ev, d.t, d.v))\n .on('mouseout', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('mouseout', ev, d.t, d.v))\n .attr('rx', radius > 0 ? radius : null)\n .attr('ry', radius > 0 ? radius : null))\n .call((selection: any) => this.#appendText(selection)),\n (update: any) => update\n .selectAll('rect')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-bg`))\n .attr('width', width)\n .attr('height', height)\n .attr('x', (d: SubDomain) => this.#getX(d))\n .attr('y', (d: SubDomain) => this.#getY(d))\n .attr('rx', radius)\n .attr('ry', radius),\n );\n }\n\n /**\n * Set the subDomain group X and Y position\n * @param {d3-selection} selection A d3-selection object\n */\n #setPositions(selection: any): void {\n const { options } = this.calendar.options;\n const {\n padding,\n label: { position },\n } = options.domain;\n\n selection\n .attr('x', () => {\n let pos = padding[Position.LEFT];\n if (position === 'left') {\n pos += options.x.domainHorizontalLabelWidth;\n }\n return pos;\n })\n .attr('y', () => {\n let pos = padding[Position.TOP];\n if (position === 'top') {\n pos += options.x.domainVerticalLabelHeight;\n }\n return pos;\n });\n }\n\n /**\n * Return a classname if the specified date should be highlighted\n *\n * @param {number} timestamp Unix timestamp of the current subDomain\n * @return {String} the highlight class\n */\n #classname(timestamp: Timestamp, ...otherClasses: string[]): string {\n const {\n date: { highlight },\n subDomain: { type },\n } = this.calendar.options.options;\n let classname = '';\n\n if (highlight.length > 0) {\n highlight.forEach((d) => {\n const unitFn = this.calendar.templateCollection.get(type).extractUnit;\n\n if (unitFn(+d) === unitFn(timestamp)) {\n classname = HIGHLIGHT_CLASSNAME;\n }\n });\n }\n\n return [classname, ...otherClasses].join(' ').trim();\n }\n\n #appendText(elem: any) {\n const { width, height, label } = this.calendar.options.options.subDomain;\n\n if (!label) {\n return null;\n }\n\n return elem\n .append('text')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-text`))\n .attr('x', (d: SubDomain) => this.#getX(d) + width / 2)\n .attr('y', (d: SubDomain) => this.#getY(d) + height / 2)\n .attr('text-anchor', 'middle')\n .attr('dominant-baseline', 'central')\n .text((d: SubDomain, i: number, nodes: any[]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.calendar.dateHelper.format(d.t, label, d.v, nodes[i]));\n }\n\n #getCoordinates(axis: 'x' | 'y', d: SubDomain): number {\n const { subDomain } = this.calendar.options.options;\n return (\n d[axis] *\n (subDomain[axis === 'x' ? 'width' : 'height'] + subDomain.gutter)\n );\n }\n\n #getX(d: SubDomain): number {\n return this.#getCoordinates('x', d);\n }\n\n #getY(d: SubDomain): number {\n return this.#getCoordinates('y', d);\n }\n}\n","import { select } from 'd3-selection';\nimport DomainPainter from './DomainPainter';\nimport DomainLabelPainter from './DomainLabelPainter';\nimport SubDomainPainter from '../subDomain/SubDomainPainter';\nimport { ScrollDirection } from '../constant';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { Dimensions } from '../index';\n\nconst BASE_SELECTOR = '.ch-domain-container';\nconst TRANSITION_CLASSNAME = 'in-transition';\n\nclass DomainsContainerPainter {\n calendar: CalHeatmap;\n\n domainPainter: DomainPainter;\n\n domainLabelPainter: DomainLabelPainter;\n\n subDomainPainter: SubDomainPainter;\n\n dimensions: Dimensions;\n\n root: any;\n\n transitionsQueueCount: number;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n\n this.domainPainter = new DomainPainter(calendar);\n this.subDomainPainter = new SubDomainPainter(calendar);\n this.domainLabelPainter = new DomainLabelPainter(calendar);\n this.dimensions = {\n width: 0,\n height: 0,\n };\n this.transitionsQueueCount = 0;\n }\n\n setup() {\n this.root = this.calendar.calendarPainter.root\n .attr('x', 0)\n .attr('y', 0)\n .append('svg')\n .attr('class', BASE_SELECTOR.slice(1))\n .append('svg')\n .attr('class', `${BASE_SELECTOR.slice(1)}-animation-wrapper`);\n }\n\n paint(scrollDirection: ScrollDirection): Promise[] {\n this.#startAnimation();\n\n const result = this.domainPainter.paint(scrollDirection, this.root);\n this.subDomainPainter.paint(this.domainPainter.root);\n this.domainLabelPainter.paint(this.domainPainter.root);\n\n this.#recomputeDimensions();\n\n Promise.allSettled(result).then(() => {\n this.#endAnimation();\n });\n\n return result;\n }\n\n updatePosition() {\n if (!this.root?.node()) {\n return Promise.resolve();\n }\n\n const { animationDuration } = this.calendar.options.options;\n const topHeight = this.calendar.pluginManager.getHeightFromPosition('top');\n const leftWidth = this.calendar.pluginManager.getWidthFromPosition('left');\n\n return [\n select(this.root.node().parentNode)\n .transition()\n .duration(animationDuration)\n .call((selection: any) => {\n selection.attr('x', leftWidth).attr('y', topHeight);\n })\n .end(),\n ];\n }\n\n width(): Dimensions['width'] {\n return this.dimensions.width;\n }\n\n height(): Dimensions['height'] {\n return this.dimensions.height;\n }\n\n destroy(): Promise {\n this.#startAnimation();\n\n return Promise.resolve();\n }\n\n #startAnimation() {\n if (this.root?.node()) {\n this.transitionsQueueCount += 1;\n select(this.root.node().parentNode).classed(TRANSITION_CLASSNAME, true);\n }\n }\n\n #endAnimation() {\n if (this.root?.node()) {\n this.transitionsQueueCount -= 1;\n\n if (this.transitionsQueueCount === 0) {\n select(this.root.node().parentNode).classed(\n TRANSITION_CLASSNAME,\n false,\n );\n }\n }\n }\n\n #recomputeDimensions(): void {\n const {\n animationDuration,\n verticalOrientation,\n domain: { gutter },\n } = this.calendar.options.options;\n const { dimensions: domainsDimensions } = this.domainPainter;\n\n this.dimensions = {\n width: domainsDimensions.width - (verticalOrientation ? 0 : gutter),\n height: domainsDimensions.height - (!verticalOrientation ? 0 : gutter),\n };\n\n this.root\n .transition()\n .duration(animationDuration)\n .attr('width', this.dimensions.width)\n .attr('height', this.dimensions.height);\n }\n}\n\nexport default DomainsContainerPainter;\n","import type CalHeatmap from '../CalHeatmap';\n\nclass PluginPainter {\n calendar: CalHeatmap;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n }\n\n paint(): Promise[] {\n let promises: Promise[] = [];\n\n promises = promises.concat(this.calendar.pluginManager.paintAll());\n promises = promises.concat(this.setPluginsPosition());\n\n return promises;\n }\n\n setPluginsPosition(): Promise[] {\n const { pluginManager } = this.calendar;\n const { animationDuration } = this.calendar.options.options;\n const { domainsContainerPainter } = this.calendar.calendarPainter;\n\n const top = pluginManager.getFromPosition('top');\n const right = pluginManager.getFromPosition('right');\n const bottom = pluginManager.getFromPosition('bottom');\n const left = pluginManager.getFromPosition('left');\n\n const topHeight = pluginManager.getHeightFromPosition('top');\n const leftWidth = pluginManager.getWidthFromPosition('left');\n\n const promises: Promise[] = [];\n\n let topOffset = 0;\n top.forEach((plugin) => {\n promises.push(\n plugin.root\n .transition()\n .duration(animationDuration)\n .attr('y', topOffset)\n .attr('x', leftWidth)\n .end(),\n );\n topOffset += plugin.options.dimensions!.height;\n });\n\n let leftOffset = 0;\n left.forEach((plugin) => {\n promises.push(\n plugin.root\n .transition()\n .duration(animationDuration)\n .attr('x', leftOffset)\n .attr('y', topHeight)\n .end(),\n );\n leftOffset += plugin.options.dimensions!.width;\n });\n\n bottom.forEach((plugin) => {\n promises.push(\n plugin.root\n .transition()\n .duration(animationDuration)\n .attr('x', leftWidth)\n .attr('y', topHeight + domainsContainerPainter.height())\n .end(),\n );\n });\n\n leftOffset += domainsContainerPainter.width();\n\n right.forEach((plugin) => {\n promises.push(\n plugin.root\n .transition()\n .duration(animationDuration)\n .attr('x', leftOffset)\n .attr('y', topHeight)\n .end(),\n );\n leftOffset += plugin.options.dimensions!.width;\n });\n\n return promises;\n }\n\n insideWidth() {\n return (\n this.calendar.pluginManager.getWidthFromPosition('left') +\n this.calendar.pluginManager.getWidthFromPosition('right')\n );\n }\n\n insideHeight() {\n return (\n this.calendar.pluginManager.getHeightFromPosition('top') +\n this.calendar.pluginManager.getHeightFromPosition('bottom')\n );\n }\n}\n\nexport default PluginPainter;\n","import { select } from 'd3-selection';\n\nimport DomainsContainerPainter from '../domain/DomainsContainerPainter';\nimport PluginPainter from '../plugins/PluginPainter';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport { ScrollDirection } from '../constant';\nimport type { Dimensions } from '../index';\n\nexport const DEFAULT_SELECTOR = '.ch-container';\n\nexport default class CalendarPainter {\n calendar: CalHeatmap;\n\n dimensions: Dimensions;\n\n root: any;\n\n domainsContainerPainter: DomainsContainerPainter;\n\n pluginPainter: PluginPainter;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.dimensions = {\n width: 0,\n height: 0,\n };\n this.root = null;\n this.domainsContainerPainter = new DomainsContainerPainter(calendar);\n this.pluginPainter = new PluginPainter(calendar);\n }\n\n setup(): boolean {\n const { itemSelector, theme } = this.calendar.options.options;\n\n if (!this.root) {\n this.root = select(itemSelector)\n .append('svg')\n .attr('data-theme', theme)\n .attr('class', DEFAULT_SELECTOR.slice(1));\n this.domainsContainerPainter.setup();\n }\n\n this.calendar.pluginManager.setupAll();\n\n return true;\n }\n\n paint(navigationDir: ScrollDirection = ScrollDirection.SCROLL_NONE) {\n const transitions = this.domainsContainerPainter\n .paint(navigationDir)\n .concat(this.pluginPainter.paint())\n .concat(this.domainsContainerPainter.updatePosition());\n\n this.#resize();\n\n return Promise.allSettled(transitions);\n }\n\n #getHeight(): Dimensions['height'] {\n return (\n this.domainsContainerPainter.height() + this.pluginPainter.insideHeight()\n );\n }\n\n #getWidth(): Dimensions['width'] {\n return (\n this.domainsContainerPainter.width() + this.pluginPainter.insideWidth()\n );\n }\n\n #resize(): void {\n const { options } = this.calendar.options;\n\n const newWidth = this.#getWidth();\n const newHeight = this.#getHeight();\n\n this.root\n .transition()\n .duration(options.animationDuration)\n .attr('width', newWidth)\n .attr('height', newHeight);\n\n if (\n newWidth !== this.dimensions.width ||\n newHeight !== this.dimensions.height\n ) {\n this.calendar.eventEmitter.emit(\n 'resize',\n newWidth,\n newHeight,\n this.dimensions.width,\n this.dimensions.height,\n );\n }\n\n this.dimensions = {\n width: newWidth,\n height: newHeight,\n };\n }\n\n destroy(): Promise {\n const result: Promise[] = this.calendar.pluginManager\n .destroyAll()\n .concat(this.domainsContainerPainter.destroy());\n\n if (!this.root) {\n return Promise.allSettled(result);\n }\n\n result.push(\n this.root\n .transition()\n .duration(this.calendar.options.options.animationDuration)\n .attr('width', 0)\n .attr('height', 0)\n .remove()\n .end(),\n );\n\n return Promise.allSettled(result);\n }\n}\n","/** Detect free variable `global` from Node.js. */\nvar freeGlobal = typeof global == 'object' && global && global.Object === Object && global;\n\nexport default freeGlobal;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `self`. */\nvar freeSelf = typeof self == 'object' && self && self.Object === Object && self;\n\n/** Used as a reference to the global object. */\nvar root = freeGlobal || freeSelf || Function('return this')();\n\nexport default root;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Symbol = root.Symbol;\n\nexport default Symbol;\n","import Symbol from './_Symbol.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the raw `toStringTag`.\n */\nfunction getRawTag(value) {\n var isOwn = hasOwnProperty.call(value, symToStringTag),\n tag = value[symToStringTag];\n\n try {\n value[symToStringTag] = undefined;\n var unmasked = true;\n } catch (e) {}\n\n var result = nativeObjectToString.call(value);\n if (unmasked) {\n if (isOwn) {\n value[symToStringTag] = tag;\n } else {\n delete value[symToStringTag];\n }\n }\n return result;\n}\n\nexport default getRawTag;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Used to resolve the\n * [`toStringTag`](http://ecma-international.org/ecma-262/7.0/#sec-object.prototype.tostring)\n * of values.\n */\nvar nativeObjectToString = objectProto.toString;\n\n/**\n * Converts `value` to a string using `Object.prototype.toString`.\n *\n * @private\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n */\nfunction objectToString(value) {\n return nativeObjectToString.call(value);\n}\n\nexport default objectToString;\n","import Symbol from './_Symbol.js';\nimport getRawTag from './_getRawTag.js';\nimport objectToString from './_objectToString.js';\n\n/** `Object#toString` result references. */\nvar nullTag = '[object Null]',\n undefinedTag = '[object Undefined]';\n\n/** Built-in value references. */\nvar symToStringTag = Symbol ? Symbol.toStringTag : undefined;\n\n/**\n * The base implementation of `getTag` without fallbacks for buggy environments.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nfunction baseGetTag(value) {\n if (value == null) {\n return value === undefined ? undefinedTag : nullTag;\n }\n return (symToStringTag && symToStringTag in Object(value))\n ? getRawTag(value)\n : objectToString(value);\n}\n\nexport default baseGetTag;\n","/**\n * Checks if `value` is the\n * [language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)\n * of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an object, else `false`.\n * @example\n *\n * _.isObject({});\n * // => true\n *\n * _.isObject([1, 2, 3]);\n * // => true\n *\n * _.isObject(_.noop);\n * // => true\n *\n * _.isObject(null);\n * // => false\n */\nfunction isObject(value) {\n var type = typeof value;\n return value != null && (type == 'object' || type == 'function');\n}\n\nexport default isObject;\n","import baseGetTag from './_baseGetTag.js';\nimport isObject from './isObject.js';\n\n/** `Object#toString` result references. */\nvar asyncTag = '[object AsyncFunction]',\n funcTag = '[object Function]',\n genTag = '[object GeneratorFunction]',\n proxyTag = '[object Proxy]';\n\n/**\n * Checks if `value` is classified as a `Function` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a function, else `false`.\n * @example\n *\n * _.isFunction(_);\n * // => true\n *\n * _.isFunction(/abc/);\n * // => false\n */\nfunction isFunction(value) {\n if (!isObject(value)) {\n return false;\n }\n // The use of `Object#toString` avoids issues with the `typeof` operator\n // in Safari 9 which returns 'object' for typed arrays and other constructors.\n var tag = baseGetTag(value);\n return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;\n}\n\nexport default isFunction;\n","'use strict';\nvar $ = require('../internals/export');\nvar toObject = require('../internals/to-object');\nvar nativeKeys = require('../internals/object-keys');\nvar fails = require('../internals/fails');\n\nvar FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {\n keys: function keys(it) {\n return nativeKeys(toObject(it));\n }\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\n// `IsRegExp` abstract operation\n// https://tc39.es/ecma262/#sec-isregexp\nmodule.exports = function (it) {\n var isRegExp;\n return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) === 'RegExp');\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar toLength = require('../internals/to-length');\nvar toString = require('../internals/to-string');\nvar notARegExp = require('../internals/not-a-regexp');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');\nvar IS_PURE = require('../internals/is-pure');\n\n// eslint-disable-next-line es/no-string-prototype-startswith -- safe\nvar nativeStartsWith = uncurryThis(''.startsWith);\nvar stringSlice = uncurryThis(''.slice);\nvar min = Math.min;\n\nvar CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');\n// https://github.com/zloirock/core-js/pull/702\nvar MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {\n var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith');\n return descriptor && !descriptor.writable;\n}();\n\n// `String.prototype.startsWith` method\n// https://tc39.es/ecma262/#sec-string.prototype.startswith\n$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {\n startsWith: function startsWith(searchString /* , position = 0 */) {\n var that = toString(requireObjectCoercible(this));\n notARegExp(searchString);\n var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));\n var search = toString(searchString);\n return nativeStartsWith\n ? nativeStartsWith(that, search, index)\n : stringSlice(that, index, index + search.length) === search;\n }\n});\n","'use strict';\nvar isRegExp = require('../internals/is-regexp');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it) {\n if (isRegExp(it)) {\n throw new $TypeError(\"The method doesn't accept regular expressions\");\n } return it;\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\nmodule.exports = function (METHOD_NAME) {\n var regexp = /./;\n try {\n '/./'[METHOD_NAME](regexp);\n } catch (error1) {\n try {\n regexp[MATCH] = false;\n return '/./'[METHOD_NAME](regexp);\n } catch (error2) { /* empty */ }\n } return false;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar objectGetPrototypeOf = require('../internals/object-get-prototype-of');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\nvar propertyIsEnumerable = uncurryThis($propertyIsEnumerable);\nvar push = uncurryThis([].push);\n\n// in some IE versions, `propertyIsEnumerable` returns incorrect result on integer keys\n// of `null` prototype objects\nvar IE_BUG = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-create -- safe\n var O = Object.create(null);\n O[2] = 2;\n return !propertyIsEnumerable(O, 2);\n});\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n return function (it) {\n var O = toIndexedObject(it);\n var keys = objectKeys(O);\n var IE_WORKAROUND = IE_BUG && objectGetPrototypeOf(O) === null;\n var length = keys.length;\n var i = 0;\n var result = [];\n var key;\n while (length > i) {\n key = keys[i++];\n if (!DESCRIPTORS || (IE_WORKAROUND ? key in O : propertyIsEnumerable(O, key))) {\n push(result, TO_ENTRIES ? [key, O[key]] : O[key]);\n }\n }\n return result;\n };\n};\n\nmodule.exports = {\n // `Object.entries` method\n // https://tc39.es/ecma262/#sec-object.entries\n entries: createMethod(true),\n // `Object.values` method\n // https://tc39.es/ecma262/#sec-object.values\n values: createMethod(false)\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $entries = require('../internals/object-to-array').entries;\n\n// `Object.entries` method\n// https://tc39.es/ecma262/#sec-object.entries\n$({ target: 'Object', stat: true }, {\n entries: function entries(O) {\n return $entries(O);\n }\n});\n","import {ascending, descending} from \"d3\";\n\nexport function defined(x) {\n return x != null && !Number.isNaN(x);\n}\n\nexport function ascendingDefined(a, b) {\n return +defined(b) - +defined(a) || ascending(a, b);\n}\n\nexport function descendingDefined(a, b) {\n return +defined(b) - +defined(a) || descending(a, b);\n}\n\nexport function nonempty(x) {\n return x != null && `${x}` !== \"\";\n}\n\nexport function finite(x) {\n return isFinite(x) ? x : NaN;\n}\n\nexport function positive(x) {\n return x > 0 && isFinite(x) ? x : NaN;\n}\n\nexport function negative(x) {\n return x < 0 && isFinite(x) ? x : NaN;\n}\n","const re = /^(?:[-+]\\d{2})?\\d{4}(?:-\\d{2}(?:-\\d{2})?)?(?:T\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{3})?)?(?:Z|[-+]\\d{2}:?\\d{2})?)?$/;\n\nexport default function parse(string, fallback) {\n if (!re.test(string += \"\")) return typeof fallback === \"function\" ? fallback(string) : fallback;\n return new Date(string);\n}\n","import {utcSecond, utcMinute, utcHour, utcDay, utcWeek, utcMonth, utcYear} from \"d3\";\nimport {utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSunday} from \"d3\";\nimport {timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear} from \"d3\";\nimport {timeMonday, timeTuesday, timeWednesday, timeThursday, timeFriday, timeSaturday, timeSunday} from \"d3\";\n\nconst timeIntervals = new Map([\n [\"second\", timeSecond],\n [\"minute\", timeMinute],\n [\"hour\", timeHour],\n [\"day\", timeDay],\n [\"week\", timeWeek],\n [\"month\", timeMonth],\n [\"quarter\", timeMonth.every(3)],\n [\"half\", timeMonth.every(6)],\n [\"year\", timeYear],\n [\"monday\", timeMonday],\n [\"tuesday\", timeTuesday],\n [\"wednesday\", timeWednesday],\n [\"thursday\", timeThursday],\n [\"friday\", timeFriday],\n [\"saturday\", timeSaturday],\n [\"sunday\", timeSunday]\n]);\n\nconst utcIntervals = new Map([\n [\"second\", utcSecond],\n [\"minute\", utcMinute],\n [\"hour\", utcHour],\n [\"day\", utcDay],\n [\"week\", utcWeek],\n [\"month\", utcMonth],\n [\"quarter\", utcMonth.every(3)],\n [\"half\", utcMonth.every(6)],\n [\"year\", utcYear],\n [\"monday\", utcMonday],\n [\"tuesday\", utcTuesday],\n [\"wednesday\", utcWednesday],\n [\"thursday\", utcThursday],\n [\"friday\", utcFriday],\n [\"saturday\", utcSaturday],\n [\"sunday\", utcSunday]\n]);\n\nexport function maybeTimeInterval(interval) {\n const i = timeIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n\nexport function maybeUtcInterval(interval) {\n const i = utcIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n","import {parse as isoParse} from \"isoformat\";\nimport {color, descending, range as rangei, quantile} from \"d3\";\nimport {maybeTimeInterval, maybeUtcInterval} from \"./time.js\";\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\nexport const TypedArray = Object.getPrototypeOf(Uint8Array);\nconst objectToString = Object.prototype.toString;\n\nexport function valueof(data, value, type) {\n const valueType = typeof value;\n return valueType === \"string\"\n ? maybeTypedMap(data, field(value), type)\n : valueType === \"function\"\n ? maybeTypedMap(data, value, type)\n : valueType === \"number\" || value instanceof Date || valueType === \"boolean\"\n ? map(data, constant(value), type)\n : typeof value?.transform === \"function\"\n ? maybeTypedArrayify(value.transform(data), type)\n : maybeTypedArrayify(value, type);\n}\n\nfunction maybeTypedMap(data, f, type) {\n return map(data, type?.prototype instanceof TypedArray ? floater(f) : f, type);\n}\n\nfunction maybeTypedArrayify(data, type) {\n return type === undefined\n ? arrayify(data) // preserve undefined type\n : data instanceof type\n ? data\n : type.prototype instanceof TypedArray && !(data instanceof TypedArray)\n ? type.from(data, coerceNumber)\n : type.from(data);\n}\n\nfunction floater(f) {\n return (d, i) => coerceNumber(f(d, i));\n}\n\nexport const field = (name) => (d) => d[name];\nexport const indexOf = {transform: range};\nexport const identity = {transform: (d) => d};\nexport const zero = () => 0;\nexport const one = () => 1;\nexport const yes = () => true;\nexport const string = (x) => (x == null ? x : `${x}`);\nexport const number = (x) => (x == null ? x : +x);\nexport const boolean = (x) => (x == null ? x : !!x);\nexport const first = (x) => (x ? x[0] : undefined);\nexport const second = (x) => (x ? x[1] : undefined);\nexport const third = (x) => (x ? x[2] : undefined);\nexport const constant = (x) => () => x;\n\n// Converts a string like “p25” into a function that takes an index I and an\n// accessor function f, returning the corresponding percentile value.\nexport function percentile(reduce) {\n const p = +`${reduce}`.slice(1) / 100;\n return (I, f) => quantile(I, p, f);\n}\n\n// If the values are specified as a typed array, no coercion is required.\nexport function coerceNumbers(values) {\n return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array);\n}\n\n// Unlike Mark’s number, here we want to convert null and undefined to NaN since\n// the result will be stored in a Float64Array and we don’t want null to be\n// coerced to zero. We use Number instead of unary + to allow BigInt coercion.\nfunction coerceNumber(x) {\n return x == null ? NaN : Number(x);\n}\n\nexport function coerceDates(values) {\n return map(values, coerceDate);\n}\n\n// When coercing strings to dates, we only want to allow the ISO 8601 format\n// since the built-in string parsing of the Date constructor varies across\n// browsers. (In the future, this could be made more liberal if desired, though\n// it is still generally preferable to do date parsing yourself explicitly,\n// rather than rely on Plot.) Any non-string values are coerced to number first\n// and treated as milliseconds since UNIX epoch.\nexport function coerceDate(x) {\n return x instanceof Date && !isNaN(x)\n ? x\n : typeof x === \"string\"\n ? isoParse(x)\n : x == null || isNaN((x = +x))\n ? undefined\n : new Date(x);\n}\n\n// Some channels may allow a string constant to be specified; to differentiate\n// string constants (e.g., \"red\") from named fields (e.g., \"date\"), this\n// function tests whether the given value is a CSS color string and returns a\n// tuple [channel, constant] where one of the two is undefined, and the other is\n// the given value. If you wish to reference a named field that is also a valid\n// CSS color, use an accessor (d => d.red) instead.\nexport function maybeColorChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null ? [undefined, \"none\"] : isColor(value) ? [undefined, value] : [value, undefined];\n}\n\n// Similar to maybeColorChannel, this tests whether the given value is a number\n// indicating a constant, and otherwise assumes that it’s a channel value.\nexport function maybeNumberChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null || typeof value === \"number\" ? [undefined, value] : [value, undefined];\n}\n\n// Validates the specified optional string against the allowed list of keywords.\nexport function maybeKeyword(input, name, allowed) {\n if (input != null) return keyword(input, name, allowed);\n}\n\n// Validates the specified required string against the allowed list of keywords.\nexport function keyword(input, name, allowed) {\n const i = `${input}`.toLowerCase();\n if (!allowed.includes(i)) throw new Error(`invalid ${name}: ${input}`);\n return i;\n}\n\n// Promotes the specified data to an array as needed.\nexport function arrayify(data) {\n return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data);\n}\n\n// An optimization of type.from(values, f): if the given values are already an\n// instanceof the desired array type, the faster values.map method is used.\nexport function map(values, f, type = Array) {\n return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f);\n}\n\n// An optimization of type.from(values): if the given values are already an\n// instanceof the desired array type, the faster values.slice method is used.\nexport function slice(values, type = Array) {\n return values instanceof type ? values.slice() : type.from(values);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a primitive value.\nexport function isObject(option) {\n return option?.toString === objectToString;\n}\n\n// Disambiguates a scale options object (e.g., {color: {type: \"linear\"}}) from\n// some other option (e.g., {color: \"red\"}). When creating standalone legends,\n// this is used to test whether a scale is defined; this should be consistent\n// with inferScaleType when there are no channels associated with the scale, and\n// if this returns true, then normalizeScale must return non-null.\nexport function isScaleOptions(option) {\n return isObject(option) && (option.type !== undefined || option.domain !== undefined);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a channel value\n// definition expressed as a channel transform (e.g., {transform: …}).\nexport function isOptions(option) {\n return isObject(option) && typeof option.transform !== \"function\";\n}\n\n// Disambiguates a sort transform (e.g., {sort: \"date\"}) from a channel domain\n// sort definition (e.g., {sort: {y: \"x\"}}).\nexport function isDomainSort(sort) {\n return isOptions(sort) && sort.value === undefined && sort.channel === undefined;\n}\n\n// For marks specified either as [0, x] or [x1, x2], such as areas and bars.\nexport function maybeZero(x, x1, x2, x3 = identity) {\n if (x1 === undefined && x2 === undefined) {\n // {x} or {}\n (x1 = 0), (x2 = x === undefined ? x3 : x);\n } else if (x1 === undefined) {\n // {x, x2} or {x2}\n x1 = x === undefined ? 0 : x;\n } else if (x2 === undefined) {\n // {x, x1} or {x1}\n x2 = x === undefined ? 0 : x;\n }\n return [x1, x2];\n}\n\n// For marks that have x and y channels (e.g., cell, dot, line, text).\nexport function maybeTuple(x, y) {\n return x === undefined && y === undefined ? [first, second] : [x, y];\n}\n\n// A helper for extracting the z channel, if it is variable. Used by transforms\n// that require series, such as moving average and normalize.\nexport function maybeZ({z, fill, stroke} = {}) {\n if (z === undefined) [z] = maybeColorChannel(fill);\n if (z === undefined) [z] = maybeColorChannel(stroke);\n return z;\n}\n\n// Returns a Uint32Array with elements [0, 1, 2, … data.length - 1].\nexport function range(data) {\n const n = data.length;\n const r = new Uint32Array(n);\n for (let i = 0; i < n; ++i) r[i] = i;\n return r;\n}\n\n// Returns a filtered range of data given the test function.\nexport function where(data, test) {\n return range(data).filter((i) => test(data[i], i, data));\n}\n\n// Returns an array [values[index[0]], values[index[1]], …].\nexport function take(values, index) {\n return map(index, (i) => values[i]);\n}\n\n// Based on InternMap (d3.group).\nexport function keyof(value) {\n return value !== null && typeof value === \"object\" ? value.valueOf() : value;\n}\n\nexport function maybeInput(key, options) {\n if (options[key] !== undefined) return options[key];\n switch (key) {\n case \"x1\":\n case \"x2\":\n key = \"x\";\n break;\n case \"y1\":\n case \"y2\":\n key = \"y\";\n break;\n }\n return options[key];\n}\n\nexport function column(source) {\n // Defines a column whose values are lazily populated by calling the returned\n // setter. If the given source is labeled, the label is propagated to the\n // returned column definition.\n let value;\n return [\n {\n transform: () => value,\n label: labelof(source)\n },\n (v) => (value = v)\n ];\n}\n\n// Like column, but allows the source to be null.\nexport function maybeColumn(source) {\n return source == null ? [source] : column(source);\n}\n\nexport function labelof(value, defaultValue) {\n return typeof value === \"string\" ? value : value && value.label !== undefined ? value.label : defaultValue;\n}\n\n// Assuming that both x1 and x2 and lazy columns (per above), this derives a new\n// a column that’s the average of the two, and which inherits the column label\n// (if any). Both input columns are assumed to be quantitative. If either column\n// is temporal, the returned column is also temporal.\nexport function mid(x1, x2) {\n return {\n transform(data) {\n const X1 = x1.transform(data);\n const X2 = x2.transform(data);\n return isTemporal(X1) || isTemporal(X2)\n ? map(X1, (_, i) => new Date((+X1[i] + +X2[i]) / 2))\n : map(X1, (_, i) => (+X1[i] + +X2[i]) / 2, Float64Array);\n },\n label: x1.label\n };\n}\n\n// If interval is not nullish, converts interval shorthand such as a number (for\n// multiples) or a time interval name (such as “day”) to a {floor, offset,\n// range} object similar to a D3 time interval.\nexport function maybeInterval(interval, type) {\n if (interval == null) return;\n if (typeof interval === \"number\") {\n if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval;\n const n = Math.abs(interval);\n return interval < 0\n ? {\n floor: (d) => Math.floor(d * n) / n,\n offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo * n), hi * n).map((x) => x / n)\n }\n : {\n floor: (d) => Math.floor(d / n) * n,\n offset: (d) => d + n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo / n), hi / n).map((x) => x * n)\n };\n }\n if (typeof interval === \"string\") return (type === \"time\" ? maybeTimeInterval : maybeUtcInterval)(interval);\n if (typeof interval.floor !== \"function\") throw new Error(\"invalid interval; missing floor method\");\n if (typeof interval.offset !== \"function\") throw new Error(\"invalid interval; missing offset method\");\n return interval;\n}\n\n// Like maybeInterval, but requires a range method too.\nexport function maybeRangeInterval(interval, type) {\n interval = maybeInterval(interval, type);\n if (interval && typeof interval.range !== \"function\") throw new Error(\"invalid interval: missing range method\");\n return interval;\n}\n\n// Like maybeRangeInterval, but requires a ceil method too.\nexport function maybeNiceInterval(interval, type) {\n interval = maybeRangeInterval(interval, type);\n if (interval && typeof interval.ceil !== \"function\") throw new Error(\"invalid interval: missing ceil method\");\n return interval;\n}\n\n// This distinguishes between per-dimension options and a standalone value.\nexport function maybeValue(value) {\n return value === undefined || isOptions(value) ? value : {value};\n}\n\n// Coerces the given channel values (if any) to numbers. This is useful when\n// values will be interpolated into other code, such as an SVG transform, and\n// where we don’t wish to allow unexpected behavior for weird input.\nexport function numberChannel(source) {\n return source == null\n ? null\n : {\n transform: (data) => valueof(data, source, Float64Array),\n label: labelof(source)\n };\n}\n\nexport function isTuples(data) {\n if (!isIterable(data)) return false;\n for (const d of data) {\n if (d == null) continue;\n return typeof d === \"object\" && \"0\" in d && \"1\" in d;\n }\n}\n\nexport function isIterable(value) {\n return value && typeof value[Symbol.iterator] === \"function\";\n}\n\nexport function isTextual(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value !== \"object\" || value instanceof Date;\n }\n}\n\nexport function isOrdinal(values) {\n for (const value of values) {\n if (value == null) continue;\n const type = typeof value;\n return type === \"string\" || type === \"boolean\";\n }\n}\n\nexport function isTemporal(values) {\n for (const value of values) {\n if (value == null) continue;\n return value instanceof Date;\n }\n}\n\n// Are these strings that might represent dates? This is stricter than ISO 8601\n// because we want to ignore false positives on numbers; for example, the string\n// \"1192\" is more likely to represent a number than a date even though it is\n// valid ISO 8601 representing 1192-01-01.\nexport function isTemporalString(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"string\" && isNaN(value) && isoParse(value);\n }\n}\n\n// Are these strings that might represent numbers? This is stricter than\n// coercion because we want to ignore false positives on e.g. empty strings.\nexport function isNumericString(values) {\n for (const value of values) {\n if (value == null) continue;\n if (typeof value !== \"string\") return false;\n if (!value.trim()) continue;\n return !isNaN(value);\n }\n}\n\nexport function isNumeric(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"number\";\n }\n}\n\n// Returns true if every non-null value in the specified iterable of values\n// passes the specified predicate, and there is at least one non-null value;\n// returns false if at least one non-null value does not pass the specified\n// predicate; otherwise returns undefined (as if all values are null).\nexport function isEvery(values, is) {\n let every;\n for (const value of values) {\n if (value == null) continue;\n if (!is(value)) return false;\n every = true;\n }\n return every;\n}\n\n// Mostly relies on d3-color, with a few extra color keywords. Currently this\n// strictly requires that the value be a string; we might want to apply string\n// coercion here, though note that d3-color instances would need to support\n// valueOf to work correctly with InternMap.\n// https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint\nexport function isColor(value) {\n if (typeof value !== \"string\") return false;\n value = value.toLowerCase().trim();\n return (\n value === \"none\" ||\n value === \"currentcolor\" ||\n (value.startsWith(\"url(\") && value.endsWith(\")\")) || // , e.g. pattern or gradient\n (value.startsWith(\"var(\") && value.endsWith(\")\")) || // CSS variable\n color(value) !== null\n );\n}\n\nexport function isOpacity(value) {\n return typeof value === \"number\" && ((0 <= value && value <= 1) || isNaN(value));\n}\n\nexport function isNoneish(value) {\n return value == null || isNone(value);\n}\n\nexport function isNone(value) {\n return /^\\s*none\\s*$/i.test(value);\n}\n\nexport function isRound(value) {\n return /^\\s*round\\s*$/i.test(value);\n}\n\nexport function maybeFrameAnchor(value = \"middle\") {\n return keyword(value, \"frameAnchor\", [\n \"middle\",\n \"top-left\",\n \"top\",\n \"top-right\",\n \"right\",\n \"bottom-right\",\n \"bottom\",\n \"bottom-left\",\n \"left\"\n ]);\n}\n\n// Like a sort comparator, returns a positive value if the given array of values\n// is in ascending order, a negative value if the values are in descending\n// order. Assumes monotonicity; only tests the first and last values.\nexport function orderof(values) {\n if (values == null) return;\n const first = values[0];\n const last = values[values.length - 1];\n return descending(first, last);\n}\n\n// Unlike {...defaults, ...options}, this ensures that any undefined (but\n// present) properties in options inherit the given default value.\nexport function inherit(options = {}, ...rest) {\n let o = options;\n for (const defaults of rest) {\n for (const key in defaults) {\n if (o[key] === undefined) {\n const value = defaults[key];\n if (o === options) o = {...o, [key]: value};\n else o[key] = value;\n }\n }\n }\n return o;\n}\n\n// Given an iterable of named things (objects with a name property), returns a\n// corresponding object with properties associated with the given name.\nexport function named(things) {\n console.warn(\"named iterables are deprecated; please use an object instead\");\n const names = new Set();\n return Object.fromEntries(\n Array.from(things, (thing) => {\n const {name} = thing;\n if (name == null) throw new Error(\"missing name\");\n const key = `${name}`;\n if (key === \"__proto__\") throw new Error(`illegal name: ${key}`);\n if (names.has(key)) throw new Error(`duplicate name: ${key}`);\n names.add(key);\n return [name, thing];\n })\n );\n}\n\nexport function maybeNamed(things) {\n return isIterable(things) ? named(things) : things;\n}\n","// Positional scales have associated axes, and for ordinal data, a point or band\n// scale is used instead of an ordinal scale.\nexport const position = Symbol(\"position\");\n\n// Color scales default to the turbo interpolator for quantitative data, and to\n// the Tableau10 scheme for ordinal data. Color scales may also have an\n// associated legend.\nexport const color = Symbol(\"color\");\n\n// Radius scales default to the sqrt type, have a default range of [0, 3], and a\n// default domain from 0 to the median first quartile of associated channels.\nexport const radius = Symbol(\"radius\");\n\n// Length scales default to the linear type, have a default range of [0, 12],\n// and a default domain from 0 to the median median of associated channels.\nexport const length = Symbol(\"length\");\n\n// Opacity scales have a default range of [0, 1], and a default domain from 0 to\n// the maximum value of associated channels.\nexport const opacity = Symbol(\"opacity\");\n\n// Symbol scales have a default range of categorical symbols.\nexport const symbol = Symbol(\"symbol\");\n\n// TODO Rather than hard-coding the list of known scale names, collect the names\n// and categories for each plot specification, so that custom marks can register\n// custom scales.\nexport const registry = new Map([\n [\"x\", position],\n [\"y\", position],\n [\"fx\", position],\n [\"fy\", position],\n [\"r\", radius],\n [\"color\", color],\n [\"opacity\", opacity],\n [\"symbol\", symbol],\n [\"length\", length]\n]);\n","import {symbolAsterisk, symbolDiamond2, symbolPlus, symbolSquare2, symbolTriangle2, symbolTimes} from \"d3\";\nimport {symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye} from \"d3\";\n\nexport const sqrt3 = Math.sqrt(3);\nexport const sqrt4_3 = 2 / sqrt3;\n\nconst symbolHexagon = {\n draw(context, size) {\n const rx = Math.sqrt(size / Math.PI),\n ry = rx * sqrt4_3,\n hy = ry / 2;\n context.moveTo(0, ry);\n context.lineTo(rx, hy);\n context.lineTo(rx, -hy);\n context.lineTo(0, -ry);\n context.lineTo(-rx, -hy);\n context.lineTo(-rx, hy);\n context.closePath();\n }\n};\n\nconst symbols = new Map([\n [\"asterisk\", symbolAsterisk],\n [\"circle\", symbolCircle],\n [\"cross\", symbolCross],\n [\"diamond\", symbolDiamond],\n [\"diamond2\", symbolDiamond2],\n [\"hexagon\", symbolHexagon],\n [\"plus\", symbolPlus],\n [\"square\", symbolSquare],\n [\"square2\", symbolSquare2],\n [\"star\", symbolStar],\n [\"times\", symbolTimes],\n [\"triangle\", symbolTriangle],\n [\"triangle2\", symbolTriangle2],\n [\"wye\", symbolWye]\n]);\n\nfunction isSymbolObject(value) {\n return value && typeof value.draw === \"function\";\n}\n\nexport function isSymbol(value) {\n if (isSymbolObject(value)) return true;\n if (typeof value !== \"string\") return false;\n return symbols.has(value.toLowerCase());\n}\n\nexport function maybeSymbol(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return symbol;\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return value;\n throw new Error(`invalid symbol: ${symbol}`);\n}\n\nexport function maybeSymbolChannel(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return [undefined, symbol];\n if (typeof symbol === \"string\") {\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return [undefined, value];\n }\n return [symbol, undefined];\n}\n","let warnings = 0;\n\nexport function consumeWarnings() {\n const w = warnings;\n warnings = 0;\n return w;\n}\n\nexport function warn(message) {\n console.warn(message);\n ++warnings;\n}\n","import {\n interpolateBlues,\n interpolateBrBG,\n interpolateBuGn,\n interpolateBuPu,\n interpolateGnBu,\n interpolateGreens,\n interpolateGreys,\n interpolateOranges,\n interpolateOrRd,\n interpolatePiYG,\n interpolatePRGn,\n interpolatePuBu,\n interpolatePuBuGn,\n interpolatePuOr,\n interpolatePuRd,\n interpolatePurples,\n interpolateRdBu,\n interpolateRdGy,\n interpolateRdPu,\n interpolateRdYlBu,\n interpolateRdYlGn,\n interpolateReds,\n interpolateSpectral,\n interpolateYlGn,\n interpolateYlGnBu,\n interpolateYlOrBr,\n interpolateYlOrRd,\n interpolateTurbo,\n interpolateViridis,\n interpolateMagma,\n interpolateInferno,\n interpolatePlasma,\n interpolateCividis,\n interpolateCubehelixDefault,\n interpolateWarm,\n interpolateCool,\n interpolateRainbow,\n interpolateSinebow,\n quantize,\n schemeAccent,\n schemeBlues,\n schemeBrBG,\n schemeBuGn,\n schemeBuPu,\n schemeCategory10,\n schemeDark2,\n schemeGnBu,\n schemeGreens,\n schemeGreys,\n schemeOranges,\n schemeOrRd,\n schemePaired,\n schemePastel1,\n schemePastel2,\n schemePiYG,\n schemePRGn,\n schemePuBu,\n schemePuBuGn,\n schemePuOr,\n schemePuRd,\n schemePurples,\n schemeRdBu,\n schemeRdGy,\n schemeRdPu,\n schemeRdYlBu,\n schemeRdYlGn,\n schemeReds,\n schemeSet1,\n schemeSet2,\n schemeSet3,\n schemeSpectral,\n schemeTableau10,\n schemeYlGn,\n schemeYlGnBu,\n schemeYlOrBr,\n schemeYlOrRd\n} from \"d3\";\n\nconst ordinalSchemes = new Map([\n // categorical\n [\"accent\", schemeAccent],\n [\"category10\", schemeCategory10],\n [\"dark2\", schemeDark2],\n [\"paired\", schemePaired],\n [\"pastel1\", schemePastel1],\n [\"pastel2\", schemePastel2],\n [\"set1\", schemeSet1],\n [\"set2\", schemeSet2],\n [\"set3\", schemeSet3],\n [\"tableau10\", schemeTableau10],\n\n // diverging\n [\"brbg\", scheme11(schemeBrBG, interpolateBrBG)],\n [\"prgn\", scheme11(schemePRGn, interpolatePRGn)],\n [\"piyg\", scheme11(schemePiYG, interpolatePiYG)],\n [\"puor\", scheme11(schemePuOr, interpolatePuOr)],\n [\"rdbu\", scheme11(schemeRdBu, interpolateRdBu)],\n [\"rdgy\", scheme11(schemeRdGy, interpolateRdGy)],\n [\"rdylbu\", scheme11(schemeRdYlBu, interpolateRdYlBu)],\n [\"rdylgn\", scheme11(schemeRdYlGn, interpolateRdYlGn)],\n [\"spectral\", scheme11(schemeSpectral, interpolateSpectral)],\n\n // reversed diverging (for temperature data)\n [\"burd\", scheme11r(schemeRdBu, interpolateRdBu)],\n [\"buylrd\", scheme11r(schemeRdYlBu, interpolateRdYlBu)],\n\n // sequential (single-hue)\n [\"blues\", scheme9(schemeBlues, interpolateBlues)],\n [\"greens\", scheme9(schemeGreens, interpolateGreens)],\n [\"greys\", scheme9(schemeGreys, interpolateGreys)],\n [\"oranges\", scheme9(schemeOranges, interpolateOranges)],\n [\"purples\", scheme9(schemePurples, interpolatePurples)],\n [\"reds\", scheme9(schemeReds, interpolateReds)],\n\n // sequential (multi-hue)\n [\"turbo\", schemei(interpolateTurbo)],\n [\"viridis\", schemei(interpolateViridis)],\n [\"magma\", schemei(interpolateMagma)],\n [\"inferno\", schemei(interpolateInferno)],\n [\"plasma\", schemei(interpolatePlasma)],\n [\"cividis\", schemei(interpolateCividis)],\n [\"cubehelix\", schemei(interpolateCubehelixDefault)],\n [\"warm\", schemei(interpolateWarm)],\n [\"cool\", schemei(interpolateCool)],\n [\"bugn\", scheme9(schemeBuGn, interpolateBuGn)],\n [\"bupu\", scheme9(schemeBuPu, interpolateBuPu)],\n [\"gnbu\", scheme9(schemeGnBu, interpolateGnBu)],\n [\"orrd\", scheme9(schemeOrRd, interpolateOrRd)],\n [\"pubu\", scheme9(schemePuBu, interpolatePuBu)],\n [\"pubugn\", scheme9(schemePuBuGn, interpolatePuBuGn)],\n [\"purd\", scheme9(schemePuRd, interpolatePuRd)],\n [\"rdpu\", scheme9(schemeRdPu, interpolateRdPu)],\n [\"ylgn\", scheme9(schemeYlGn, interpolateYlGn)],\n [\"ylgnbu\", scheme9(schemeYlGnBu, interpolateYlGnBu)],\n [\"ylorbr\", scheme9(schemeYlOrBr, interpolateYlOrBr)],\n [\"ylorrd\", scheme9(schemeYlOrRd, interpolateYlOrRd)],\n\n // cyclical\n [\"rainbow\", schemeicyclical(interpolateRainbow)],\n [\"sinebow\", schemeicyclical(interpolateSinebow)]\n]);\n\nfunction scheme9(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 1) return [scheme[3][1]]; // favor midpoint\n if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker\n n = Math.max(3, Math.floor(n));\n return n > 9 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11r(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse();\n };\n}\n\nfunction schemei(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.max(2, Math.floor(n)));\n}\n\nfunction schemeicyclical(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.floor(n) + 1).slice(0, -1);\n}\n\nexport function ordinalScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`);\n return ordinalSchemes.get(s);\n}\n\nexport function ordinalRange(scheme, length) {\n const s = ordinalScheme(scheme);\n const r = typeof s === \"function\" ? s({length}) : s;\n return r.length !== length ? r.slice(0, length) : r;\n}\n\n// If the specified domain contains only booleans (ignoring null and undefined),\n// returns a corresponding range where false is mapped to the low color and true\n// is mapped to the high color of the specified scheme.\nexport function maybeBooleanRange(domain, scheme = \"greys\") {\n const range = new Set();\n const [f, t] = ordinalRange(scheme, 2);\n for (const value of domain) {\n if (value == null) continue;\n if (value === true) range.add(t);\n else if (value === false) range.add(f);\n else return;\n }\n return [...range];\n}\n\nconst quantitativeSchemes = new Map([\n // diverging\n [\"brbg\", interpolateBrBG],\n [\"prgn\", interpolatePRGn],\n [\"piyg\", interpolatePiYG],\n [\"puor\", interpolatePuOr],\n [\"rdbu\", interpolateRdBu],\n [\"rdgy\", interpolateRdGy],\n [\"rdylbu\", interpolateRdYlBu],\n [\"rdylgn\", interpolateRdYlGn],\n [\"spectral\", interpolateSpectral],\n\n // reversed diverging (for temperature data)\n [\"burd\", (t) => interpolateRdBu(1 - t)],\n [\"buylrd\", (t) => interpolateRdYlBu(1 - t)],\n\n // sequential (single-hue)\n [\"blues\", interpolateBlues],\n [\"greens\", interpolateGreens],\n [\"greys\", interpolateGreys],\n [\"purples\", interpolatePurples],\n [\"reds\", interpolateReds],\n [\"oranges\", interpolateOranges],\n\n // sequential (multi-hue)\n [\"turbo\", interpolateTurbo],\n [\"viridis\", interpolateViridis],\n [\"magma\", interpolateMagma],\n [\"inferno\", interpolateInferno],\n [\"plasma\", interpolatePlasma],\n [\"cividis\", interpolateCividis],\n [\"cubehelix\", interpolateCubehelixDefault],\n [\"warm\", interpolateWarm],\n [\"cool\", interpolateCool],\n [\"bugn\", interpolateBuGn],\n [\"bupu\", interpolateBuPu],\n [\"gnbu\", interpolateGnBu],\n [\"orrd\", interpolateOrRd],\n [\"pubugn\", interpolatePuBuGn],\n [\"pubu\", interpolatePuBu],\n [\"purd\", interpolatePuRd],\n [\"rdpu\", interpolateRdPu],\n [\"ylgnbu\", interpolateYlGnBu],\n [\"ylgn\", interpolateYlGn],\n [\"ylorbr\", interpolateYlOrBr],\n [\"ylorrd\", interpolateYlOrRd],\n\n // cyclical\n [\"rainbow\", interpolateRainbow],\n [\"sinebow\", interpolateSinebow]\n]);\n\nexport function quantitativeScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`);\n return quantitativeSchemes.get(s);\n}\n\nconst divergingSchemes = new Set([\n \"brbg\",\n \"prgn\",\n \"piyg\",\n \"puor\",\n \"rdbu\",\n \"rdgy\",\n \"rdylbu\",\n \"rdylgn\",\n \"spectral\",\n \"burd\",\n \"buylrd\"\n]);\n\nexport function isDivergingScheme(scheme) {\n return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase());\n}\n","import {\n descending,\n extent,\n interpolateHcl,\n interpolateHsl,\n interpolateLab,\n interpolateNumber,\n interpolateRgb,\n interpolateRound,\n min,\n max,\n median,\n quantile,\n quantize,\n reverse as reverseof,\n scaleLinear,\n scaleLog,\n scalePow,\n scaleQuantile,\n scaleSymlog,\n scaleThreshold,\n scaleIdentity,\n ticks\n} from \"d3\";\nimport {positive, negative, finite} from \"../defined.js\";\nimport {arrayify, constant, orderof, slice, maybeNiceInterval, maybeRangeInterval} from \"../options.js\";\nimport {ordinalRange, quantitativeScheme} from \"./schemes.js\";\nimport {registry, radius, opacity, color, length} from \"./index.js\";\n\nexport const flip = (i) => (t) => i(1 - t);\nconst unit = [0, 1];\n\nconst interpolators = new Map([\n // numbers\n [\"number\", interpolateNumber],\n\n // color spaces\n [\"rgb\", interpolateRgb],\n [\"hsl\", interpolateHsl],\n [\"hcl\", interpolateHcl],\n [\"lab\", interpolateLab]\n]);\n\nexport function maybeInterpolator(interpolate) {\n const i = `${interpolate}`.toLowerCase();\n if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`);\n return interpolators.get(i);\n}\n\nexport function createScaleQ(\n key,\n scale,\n channels,\n {\n type,\n nice,\n clamp,\n zero,\n domain = inferAutoDomain(key, channels),\n unknown,\n round,\n scheme,\n interval,\n range = registry.get(key) === radius\n ? inferRadialRange(channels, domain)\n : registry.get(key) === length\n ? inferLengthRange(channels, domain)\n : registry.get(key) === opacity\n ? unit\n : undefined,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : type === \"cyclical\" ? \"rainbow\" : \"turbo\")\n : round\n ? interpolateRound\n : interpolateNumber,\n reverse\n }\n) {\n interval = maybeRangeInterval(interval, type);\n if (type === \"cyclical\" || type === \"sequential\") type = \"linear\"; // shorthand for color schemes\n reverse = !!reverse;\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n if (interpolate.length === 1) {\n if (reverse) {\n interpolate = flip(interpolate);\n reverse = false;\n }\n if (range === undefined) {\n range = Float64Array.from(domain, (_, i) => i / (domain.length - 1));\n if (range.length === 2) range = unit; // optimize common case of [0, 1]\n }\n scale.interpolate((range === unit ? constant : interpolatePiecewise)(interpolate));\n } else {\n scale.interpolate(interpolate);\n }\n\n // If a zero option is specified, we assume that the domain is numeric, and we\n // want to ensure that the domain crosses zero. However, note that the domain\n // may be reversed (descending) so we shouldn’t assume that the first value is\n // smaller than the last; and also it’s possible that the domain has more than\n // two values for a “poly” scale. And lastly be careful not to mutate input!\n if (zero) {\n const [min, max] = extent(domain);\n if (min > 0 || max < 0) {\n domain = slice(domain);\n if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0;\n // [2, 1] or [-2, -1]\n else domain[0] = 0; // [1, 2] or [-1, -2]\n }\n }\n\n if (reverse) domain = reverseof(domain);\n scale.domain(domain).unknown(unknown);\n if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain());\n if (range !== undefined) scale.range(range);\n if (clamp) scale.clamp(clamp);\n return {type, domain, range, scale, interpolate, interval};\n}\n\nfunction maybeNice(nice, type) {\n return nice === true ? undefined : typeof nice === \"number\" ? nice : maybeNiceInterval(nice, type);\n}\n\nexport function createScaleLinear(key, channels, options) {\n return createScaleQ(key, scaleLinear(), channels, options);\n}\n\nexport function createScaleSqrt(key, channels, options) {\n return createScalePow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScalePow(key, channels, {exponent = 1, ...options}) {\n return createScaleQ(key, scalePow().exponent(exponent), channels, {...options, type: \"pow\"});\n}\n\nexport function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) {\n return createScaleQ(key, scaleLog().base(base), channels, {...options, domain});\n}\n\nexport function createScaleSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleQ(key, scaleSymlog().constant(constant), channels, options);\n}\n\nexport function createScaleQuantile(\n key,\n channels,\n {\n range,\n quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead\n n = quantiles,\n scheme = \"rdylbu\",\n domain = inferQuantileDomain(channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n if (range === undefined) {\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n }\n if (domain.length > 0) {\n domain = scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles();\n }\n return createScaleThreshold(key, channels, {domain, range, reverse, unknown});\n}\n\nexport function createScaleQuantize(\n key,\n channels,\n {\n range,\n n = range === undefined ? 5 : (range = [...range]).length,\n scheme = \"rdylbu\",\n domain = inferAutoDomain(key, channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n const [min, max] = extent(domain);\n let thresholds;\n if (range === undefined) {\n thresholds = ticks(min, max, n); // approximate number of nice, round thresholds\n if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound\n if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound\n n = thresholds.length + 1;\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n } else {\n thresholds = quantize(interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range\n if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types\n }\n if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain\n return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown});\n}\n\nexport function createScaleThreshold(\n key,\n channels,\n {\n domain = [0], // explicit thresholds in ascending order\n unknown,\n scheme = \"rdylbu\",\n interpolate,\n range = interpolate !== undefined\n ? quantize(interpolate, domain.length + 1)\n : registry.get(key) === color\n ? ordinalRange(scheme, domain.length + 1)\n : undefined,\n reverse\n }\n) {\n domain = arrayify(domain);\n const sign = orderof(domain); // preserve descending domain\n if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`);\n if (reverse) range = reverseof(range); // domain ascending, so reverse range\n return {\n type: \"threshold\",\n scale: scaleThreshold(sign < 0 ? reverseof(domain) : domain, range === undefined ? [] : range).unknown(unknown),\n domain,\n range\n };\n}\n\nfunction isOrdered(domain, sign) {\n for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) {\n const s = descending(d, (d = domain[i]));\n if (s !== 0 && s !== sign) return false;\n }\n return true;\n}\n\nexport function createScaleIdentity() {\n return {type: \"identity\", scale: scaleIdentity()};\n}\n\nexport function inferDomain(channels, f = finite) {\n return channels.length\n ? [\n min(channels, ({value}) => (value === undefined ? value : min(value, f))),\n max(channels, ({value}) => (value === undefined ? value : max(value, f)))\n ]\n : [0, 1];\n}\n\nfunction inferAutoDomain(key, channels) {\n const type = registry.get(key);\n return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain)(channels);\n}\n\nfunction inferZeroDomain(channels) {\n return [0, channels.length ? max(channels, ({value}) => (value === undefined ? value : max(value, finite))) : 1];\n}\n\n// We don’t want the upper bound of the radial domain to be zero, as this would\n// be degenerate, so we ignore nonpositive values. We also don’t want the\n// maximum default radius to exceed 30px.\nfunction inferRadialRange(channels, domain) {\n const hint = channels.find(({radius}) => radius !== undefined);\n if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins\n const h25 = quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : quantile(value, 0.25, positive)));\n const range = domain.map((d) => 3 * Math.sqrt(d / h25));\n const k = 30 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\n// We want a length scale’s domain to go from zero to a positive value, and to\n// treat negative lengths if any as inverted vectors of equivalent magnitude. We\n// also don’t want the maximum default length to exceed 60px.\nfunction inferLengthRange(channels, domain) {\n const h50 = median(channels, ({value}) => (value === undefined ? NaN : median(value, Math.abs)));\n const range = domain.map((d) => (12 * d) / h50);\n const k = 60 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\nfunction inferLogDomain(channels) {\n for (const {value} of channels) {\n if (value !== undefined) {\n for (let v of value) {\n if (v > 0) return inferDomain(channels, positive);\n if (v < 0) return inferDomain(channels, negative);\n }\n }\n }\n return [1, 10];\n}\n\nfunction inferQuantileDomain(channels) {\n const domain = [];\n for (const {value} of channels) {\n if (value === undefined) continue;\n for (const v of value) domain.push(v);\n }\n return domain;\n}\n\nexport function interpolatePiecewise(interpolate) {\n return (i, j) => (t) => interpolate(i + t * (j - i));\n}\n","import {\n descending,\n interpolateNumber,\n interpolateRgb,\n piecewise,\n scaleDiverging,\n scaleDivergingLog,\n scaleDivergingPow,\n scaleDivergingSymlog\n} from \"d3\";\nimport {positive, negative} from \"../defined.js\";\nimport {quantitativeScheme} from \"./schemes.js\";\nimport {registry, color} from \"./index.js\";\nimport {inferDomain, maybeInterpolator, flip, interpolatePiecewise} from \"./quantitative.js\";\n\nfunction createScaleD(\n key,\n scale,\n transform,\n channels,\n {\n type,\n nice,\n clamp,\n domain = inferDomain(channels),\n unknown,\n pivot = 0,\n scheme,\n range,\n symmetric = true,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : \"rdbu\")\n : interpolateNumber,\n reverse\n }\n) {\n pivot = +pivot;\n let [min, max] = domain;\n if (descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse);\n min = Math.min(min, pivot);\n max = Math.max(max, pivot);\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n\n // If an explicit range is specified, promote it to a piecewise interpolator.\n if (range !== undefined) {\n interpolate =\n interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : piecewise(interpolate, range);\n }\n\n // Reverse before normalization.\n if (reverse) interpolate = flip(interpolate);\n\n // Normalize the interpolator for symmetric difference around the pivot.\n if (symmetric) {\n const mid = transform.apply(pivot);\n const mindelta = mid - transform.apply(min);\n const maxdelta = transform.apply(max) - mid;\n if (mindelta < maxdelta) min = transform.invert(mid - maxdelta);\n else if (mindelta > maxdelta) max = transform.invert(mid + mindelta);\n }\n\n scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate);\n if (clamp) scale.clamp(clamp);\n if (nice) scale.nice(nice);\n return {type, domain: [min, max], pivot, interpolate, scale};\n}\n\nexport function createScaleDiverging(key, channels, options) {\n return createScaleD(key, scaleDiverging(), transformIdentity, channels, options);\n}\n\nexport function createScaleDivergingSqrt(key, channels, options) {\n return createScaleDivergingPow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) {\n return createScaleD(key, scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, {\n ...options,\n type: \"diverging-pow\"\n });\n}\n\nexport function createScaleDivergingLog(\n key,\n channels,\n {base = 10, pivot = 1, domain = inferDomain(channels, pivot < 0 ? negative : positive), ...options}\n) {\n return createScaleD(key, scaleDivergingLog().base((base = +base)), transformLog, channels, {\n domain,\n pivot,\n ...options\n });\n}\n\nexport function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleD(\n key,\n scaleDivergingSymlog().constant((constant = +constant)),\n transformSymlog(constant),\n channels,\n options\n );\n}\n\nconst transformIdentity = {\n apply(x) {\n return x;\n },\n invert(x) {\n return x;\n }\n};\n\nconst transformLog = {\n apply: Math.log,\n invert: Math.exp\n};\n\nconst transformSqrt = {\n apply(x) {\n return Math.sign(x) * Math.sqrt(Math.abs(x));\n },\n invert(x) {\n return Math.sign(x) * (x * x);\n }\n};\n\nfunction transformPow(exponent) {\n return exponent === 0.5\n ? transformSqrt\n : {\n apply(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), exponent);\n },\n invert(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent);\n }\n };\n}\n\nfunction transformSymlog(constant) {\n return {\n apply(x) {\n return Math.sign(x) * Math.log1p(Math.abs(x / constant));\n },\n invert(x) {\n return Math.sign(x) * Math.expm1(Math.abs(x)) * constant;\n }\n };\n}\n","import {scaleTime, scaleUtc} from \"d3\";\nimport {createScaleQ} from \"./quantitative.js\";\n\nfunction createScaleT(key, scale, channels, options) {\n return createScaleQ(key, scale, channels, options);\n}\n\nexport function createScaleTime(key, channels, options) {\n return createScaleT(key, scaleTime(), channels, options);\n}\n\nexport function createScaleUtc(key, channels, options) {\n return createScaleT(key, scaleUtc(), channels, options);\n}\n","import {InternSet, extent, quantize, reverse as reverseof, sort, symbolsFill, symbolsStroke} from \"d3\";\nimport {scaleBand, scaleOrdinal, scalePoint, scaleImplicit} from \"d3\";\nimport {ascendingDefined} from \"../defined.js\";\nimport {isNoneish, map, maybeRangeInterval} from \"../options.js\";\nimport {maybeSymbol} from \"../symbol.js\";\nimport {registry, color, position, symbol} from \"./index.js\";\nimport {maybeBooleanRange, ordinalScheme, quantitativeScheme} from \"./schemes.js\";\n\n// This denotes an implicitly ordinal color scale: the scale type was not set,\n// but the associated values are strings or booleans. If the associated defined\n// values are entirely boolean, the range will default to greys. You can opt out\n// of this by setting the type explicitly.\nexport const ordinalImplicit = Symbol(\"ordinal\");\n\nfunction createScaleO(key, scale, channels, {type, interval, domain, range, reverse, hint}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n if (type === \"categorical\" || type === ordinalImplicit) type = \"ordinal\"; // shorthand for color schemes\n if (reverse) domain = reverseof(domain);\n scale.domain(domain);\n if (range !== undefined) {\n // If the range is specified as a function, pass it the domain.\n if (typeof range === \"function\") range = range(domain);\n scale.range(range);\n }\n return {type, domain, range, scale, hint, interval};\n}\n\nexport function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n let hint;\n if (registry.get(key) === symbol) {\n hint = inferSymbolHint(channels);\n range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol);\n } else if (registry.get(key) === color) {\n if (range === undefined && (type === \"ordinal\" || type === ordinalImplicit)) {\n range = maybeBooleanRange(domain, scheme);\n if (range !== undefined) scheme = undefined; // Don’t re-apply scheme.\n }\n if (scheme === undefined && range === undefined) {\n scheme = type === \"ordinal\" ? \"turbo\" : \"tableau10\";\n }\n if (scheme !== undefined) {\n if (range !== undefined) {\n const interpolate = quantitativeScheme(scheme);\n const t0 = range[0],\n d = range[1] - range[0];\n range = ({length: n}) => quantize((t) => interpolate(t0 + d * t), n);\n } else {\n range = ordinalScheme(scheme);\n }\n }\n }\n if (unknown === scaleImplicit) {\n throw new Error(`implicit unknown on ${key} scale is not supported`);\n }\n return createScaleO(key, scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint});\n}\n\nexport function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) {\n return maybeRound(scalePoint().align(align).padding(padding), channels, options, key);\n}\n\nexport function createScaleBand(\n key,\n channels,\n {\n align = 0.5,\n padding = 0.1,\n paddingInner = padding,\n paddingOuter = key === \"fx\" || key === \"fy\" ? 0 : padding,\n ...options\n }\n) {\n return maybeRound(\n scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter),\n channels,\n options,\n key\n );\n}\n\nfunction maybeRound(scale, channels, options, key) {\n let {round} = options;\n if (round !== undefined) scale.round((round = !!round));\n scale = createScaleO(key, scale, channels, options);\n scale.round = round; // preserve for autoScaleRound\n return scale;\n}\n\nfunction inferDomain(channels, interval, key) {\n const values = new InternSet();\n for (const {value, domain} of channels) {\n if (domain !== undefined) return domain(); // see channelDomain\n if (value === undefined) continue;\n for (const v of value) values.add(v);\n }\n if (interval !== undefined) {\n const [min, max] = extent(values).map(interval.floor, interval);\n return interval.range(min, interval.offset(max));\n }\n if (values.size > 10e3 && registry.get(key) === position) {\n throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`);\n }\n return sort(values, ascendingDefined);\n}\n\n// If all channels provide a consistent hint, propagate it to the scale.\nfunction inferHint(channels, key) {\n let value;\n for (const {hint} of channels) {\n const candidate = hint?.[key];\n if (candidate === undefined) continue; // no hint here\n if (value === undefined) value = candidate;\n // first hint\n else if (value !== candidate) return; // inconsistent hint\n }\n return value;\n}\n\nfunction inferSymbolHint(channels) {\n return {\n fill: inferHint(channels, \"fill\"),\n stroke: inferHint(channels, \"stroke\")\n };\n}\n\nfunction inferSymbolRange(hint) {\n return isNoneish(hint.fill) ? symbolsStroke : symbolsFill;\n}\n","import {\n isOrdinal,\n isTemporal,\n isTemporalString,\n isNumericString,\n isScaleOptions,\n map,\n slice,\n coerceNumbers,\n coerceDates\n} from \"./options.js\";\nimport {registry, color, position, radius, opacity, symbol, length} from \"./scales/index.js\";\nimport {\n createScaleLinear,\n createScaleSqrt,\n createScalePow,\n createScaleLog,\n createScaleSymlog,\n createScaleQuantile,\n createScaleQuantize,\n createScaleThreshold,\n createScaleIdentity\n} from \"./scales/quantitative.js\";\nimport {\n createScaleDiverging,\n createScaleDivergingSqrt,\n createScaleDivergingPow,\n createScaleDivergingLog,\n createScaleDivergingSymlog\n} from \"./scales/diverging.js\";\nimport {isDivergingScheme} from \"./scales/schemes.js\";\nimport {createScaleTime, createScaleUtc} from \"./scales/temporal.js\";\nimport {createScaleOrdinal, createScalePoint, createScaleBand, ordinalImplicit} from \"./scales/ordinal.js\";\nimport {maybeSymbol} from \"./symbol.js\";\nimport {warn} from \"./warnings.js\";\n\nexport function createScales(\n channelsByScale,\n {\n label: globalLabel,\n inset: globalInset = 0,\n insetTop: globalInsetTop = globalInset,\n insetRight: globalInsetRight = globalInset,\n insetBottom: globalInsetBottom = globalInset,\n insetLeft: globalInsetLeft = globalInset,\n round,\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n facet: {label: facetLabel = globalLabel} = {},\n ...options\n } = {}\n) {\n const scales = {};\n for (const [key, channels] of channelsByScale) {\n const scaleOptions = options[key];\n const scale = createScale(key, channels, {\n round: registry.get(key) === position ? round : undefined, // only for position\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n ...scaleOptions\n });\n if (scale) {\n // populate generic scale options (percent, transform, insets)\n let {\n label = key === \"fx\" || key === \"fy\" ? facetLabel : globalLabel,\n percent,\n transform,\n inset,\n insetTop = inset !== undefined ? inset : key === \"y\" ? globalInsetTop : 0, // not fy\n insetRight = inset !== undefined ? inset : key === \"x\" ? globalInsetRight : 0, // not fx\n insetBottom = inset !== undefined ? inset : key === \"y\" ? globalInsetBottom : 0, // not fy\n insetLeft = inset !== undefined ? inset : key === \"x\" ? globalInsetLeft : 0 // not fx\n } = scaleOptions || {};\n if (transform == null) transform = undefined;\n else if (typeof transform !== \"function\") throw new Error(\"invalid scale transform; not a function\");\n scale.percent = !!percent;\n scale.label = label === undefined ? inferScaleLabel(channels, scale) : label;\n scale.transform = transform;\n if (key === \"x\" || key === \"fx\") {\n scale.insetLeft = +insetLeft;\n scale.insetRight = +insetRight;\n } else if (key === \"y\" || key === \"fy\") {\n scale.insetTop = +insetTop;\n scale.insetBottom = +insetBottom;\n }\n scales[key] = scale;\n }\n }\n return scales;\n}\n\nexport function createScaleFunctions(scales) {\n return Object.fromEntries(\n Object.entries(scales)\n .filter(([, {scale}]) => scale) // drop identity scales\n .map(([name, {scale, type, interval, label}]) => {\n scale.type = type; // for axis\n if (interval != null) scale.interval = interval; // for axis\n if (label != null) scale.label = label; // for axis\n return [name, scale];\n })\n );\n}\n\n// Mutates scale.range!\nexport function autoScaleRange(scales, dimensions) {\n const {x, y, fx, fy} = scales;\n const superdimensions = fx || fy ? outerDimensions(dimensions) : dimensions;\n if (fx) autoScaleRangeX(fx, superdimensions);\n if (fy) autoScaleRangeY(fy, superdimensions);\n const subdimensions = fx || fy ? innerDimensions(scales, dimensions) : dimensions;\n if (x) autoScaleRangeX(x, subdimensions);\n if (y) autoScaleRangeY(y, subdimensions);\n}\n\n// Channels can have labels; if all the channels for a given scale are\n// consistently labeled (i.e., have the same value if not undefined), and the\n// corresponding scale doesn’t already have an explicit label, then the\n// channels’ label is promoted to the scale. This inferred label should have an\n// orientation-appropriate arrow added when used as an axis, but we don’t want\n// to add the arrow when the label is set explicitly as an option; so, the\n// inferred label is distinguished as an object with an “inferred” property.\nfunction inferScaleLabel(channels = [], scale) {\n let label;\n for (const {label: l} of channels) {\n if (l === undefined) continue;\n if (label === undefined) label = l;\n else if (label !== l) return;\n }\n if (label === undefined) return;\n // Ignore the implicit label for temporal scales if it’s simply “date”.\n if (isTemporalScale(scale) && /^(date|time|year)$/i.test(label)) return;\n if (!isOrdinalScale(scale) && scale.percent) label = `${label} (%)`;\n return {inferred: true, toString: () => label};\n}\n\n// Returns the dimensions of the outer frame; this is subdivided into facets\n// with the margins of each facet collapsing into the outer margins.\nexport function outerDimensions(dimensions) {\n const {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width,\n height,\n facet: {\n marginTop: facetMarginTop,\n marginRight: facetMarginRight,\n marginBottom: facetMarginBottom,\n marginLeft: facetMarginLeft\n }\n } = dimensions;\n return {\n marginTop: Math.max(marginTop, facetMarginTop),\n marginRight: Math.max(marginRight, facetMarginRight),\n marginBottom: Math.max(marginBottom, facetMarginBottom),\n marginLeft: Math.max(marginLeft, facetMarginLeft),\n width,\n height\n };\n}\n\n// Returns the dimensions of each facet.\nexport function innerDimensions({fx, fy}, dimensions) {\n const {marginTop, marginRight, marginBottom, marginLeft, width, height} = outerDimensions(dimensions);\n return {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width: fx ? fx.scale.bandwidth() + marginLeft + marginRight : width,\n height: fy ? fy.scale.bandwidth() + marginTop + marginBottom : height\n };\n}\n\nfunction autoScaleRangeX(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetLeft, insetRight} = scale;\n const {width, marginLeft = 0, marginRight = 0} = dimensions;\n const left = marginLeft + insetLeft;\n const right = width - marginRight - insetRight;\n scale.range = [left, Math.max(left, right)];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRangeY(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetTop, insetBottom} = scale;\n const {height, marginTop = 0, marginBottom = 0} = dimensions;\n const top = marginTop + insetTop;\n const bottom = height - marginBottom - insetBottom;\n scale.range = [Math.max(top, bottom), top];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n else scale.range.reverse();\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRound(scale) {\n if (scale.round === undefined && isBandScale(scale) && roundError(scale) <= 30) {\n scale.scale.round(true);\n }\n}\n\n// If we were to turn on rounding for this band or point scale, how much wasted\n// space would it introduce (on both ends of the range)? This must match\n// d3.scaleBand’s rounding behavior:\n// https://github.com/d3/d3-scale/blob/83555bd759c7314420bd4240642beda5e258db9e/src/band.js#L20-L32\nfunction roundError({scale}) {\n const n = scale.domain().length;\n const [start, stop] = scale.range();\n const paddingInner = scale.paddingInner ? scale.paddingInner() : 1;\n const paddingOuter = scale.paddingOuter ? scale.paddingOuter() : scale.padding();\n const m = n - paddingInner;\n const step = Math.abs(stop - start) / Math.max(1, m + paddingOuter * 2);\n return (step - Math.floor(step)) * m;\n}\n\nfunction piecewiseRange(scale) {\n const length = scale.scale.domain().length + isThresholdScale(scale);\n if (!(length > 2)) return scale.range;\n const [start, end] = scale.range;\n return Array.from({length}, (_, i) => start + (i / (length - 1)) * (end - start));\n}\n\nexport function normalizeScale(key, scale, hint) {\n return createScale(key, hint === undefined ? undefined : [{hint}], {...scale});\n}\n\nfunction createScale(key, channels = [], options = {}) {\n const type = inferScaleType(key, channels, options);\n\n // Warn for common misuses of implicit ordinal scales. We disable this test if\n // you specify a scale interval or if you set the domain or range explicitly,\n // since setting the domain or range (typically with a cardinality of more than\n // two) is another indication that you intended for the scale to be ordinal; we\n // also disable it for facet scales since these are always band scales.\n if (\n options.type === undefined &&\n options.domain === undefined &&\n options.range === undefined &&\n options.interval == null &&\n key !== \"fx\" &&\n key !== \"fy\" &&\n isOrdinalScale({type})\n ) {\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isTemporal))\n warn(\n `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isTemporalString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isNumericString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a \"linear\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n }\n\n options.type = type; // Mutates input!\n\n // Once the scale type is known, coerce the associated channel values and any\n // explicitly-specified domain to the expected type.\n switch (type) {\n case \"diverging\":\n case \"diverging-sqrt\":\n case \"diverging-pow\":\n case \"diverging-log\":\n case \"diverging-symlog\":\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n case \"sqrt\":\n case \"threshold\":\n case \"quantile\":\n case \"pow\":\n case \"log\":\n case \"symlog\":\n options = coerceType(channels, options, coerceNumbers);\n break;\n case \"identity\":\n switch (registry.get(key)) {\n case position:\n options = coerceType(channels, options, coerceNumbers);\n break;\n case symbol:\n options = coerceType(channels, options, coerceSymbols);\n break;\n }\n break;\n case \"utc\":\n case \"time\":\n options = coerceType(channels, options, coerceDates);\n break;\n }\n\n switch (type) {\n case \"diverging\":\n return createScaleDiverging(key, channels, options);\n case \"diverging-sqrt\":\n return createScaleDivergingSqrt(key, channels, options);\n case \"diverging-pow\":\n return createScaleDivergingPow(key, channels, options);\n case \"diverging-log\":\n return createScaleDivergingLog(key, channels, options);\n case \"diverging-symlog\":\n return createScaleDivergingSymlog(key, channels, options);\n case \"categorical\":\n case \"ordinal\":\n case ordinalImplicit:\n return createScaleOrdinal(key, channels, options);\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n return createScaleLinear(key, channels, options);\n case \"sqrt\":\n return createScaleSqrt(key, channels, options);\n case \"threshold\":\n return createScaleThreshold(key, channels, options);\n case \"quantile\":\n return createScaleQuantile(key, channels, options);\n case \"quantize\":\n return createScaleQuantize(key, channels, options);\n case \"pow\":\n return createScalePow(key, channels, options);\n case \"log\":\n return createScaleLog(key, channels, options);\n case \"symlog\":\n return createScaleSymlog(key, channels, options);\n case \"utc\":\n return createScaleUtc(key, channels, options);\n case \"time\":\n return createScaleTime(key, channels, options);\n case \"point\":\n return createScalePoint(key, channels, options);\n case \"band\":\n return createScaleBand(key, channels, options);\n case \"identity\":\n return registry.get(key) === position ? createScaleIdentity() : {type: \"identity\"};\n case undefined:\n return;\n default:\n throw new Error(`unknown scale type: ${type}`);\n }\n}\n\nfunction formatScaleType(type) {\n return typeof type === \"symbol\" ? type.description : type;\n}\n\n// A special type symbol when the x and y scales are replaced with a projection.\nconst typeProjection = {toString: () => \"projection\"};\n\nfunction inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) {\n // The facet scales are always band scales; this cannot be changed.\n if (key === \"fx\" || key === \"fy\") return \"band\";\n\n // If a projection is specified, the x- and y-scales are disabled; these\n // channels will be projected rather than scaled. (But still check that none\n // of the associated channels are incompatible with a projection.)\n if ((key === \"x\" || key === \"y\") && projection != null) type = typeProjection;\n\n // If a channel dictates a scale type, make sure that it is consistent with\n // the user-specified scale type (if any) and all other channels. For example,\n // barY requires x to be a band scale and disallows any other scale type.\n for (const {type: t} of channels) {\n if (t === undefined) continue;\n else if (type === undefined) type = t;\n else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`);\n }\n\n // If the scale, a channel, or user specified a (consistent) type, return it.\n if (type === typeProjection) return;\n if (type !== undefined) return type;\n\n // If there’s no data (and no type) associated with this scale, don’t create a scale.\n if (domain === undefined && !channels.some(({value}) => value !== undefined)) return;\n\n // Some scales have default types.\n const kind = registry.get(key);\n if (kind === radius) return \"sqrt\";\n if (kind === opacity || kind === length) return \"linear\";\n if (kind === symbol) return \"ordinal\";\n\n // If the domain or range has more than two values, assume it’s ordinal. You\n // can still use a “piecewise” (or “polylinear”) scale, but you must set the\n // type explicitly.\n if ((domain || range || []).length > 2) return asOrdinalType(kind);\n\n // Otherwise, infer the scale type from the data! Prefer the domain, if\n // present, over channels. (The domain and channels should be consistently\n // typed, and the domain is more explicit and typically much smaller.) We only\n // check the first defined value for expedience and simplicity; we expect\n // that the types are consistent.\n if (domain !== undefined) {\n if (isOrdinal(domain)) return asOrdinalType(kind);\n if (isTemporal(domain)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n }\n\n // If any channel is ordinal or temporal, it takes priority.\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isOrdinal)) return asOrdinalType(kind);\n if (values.some(isTemporal)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n}\n\n// Positional scales default to a point scale instead of an ordinal scale.\nfunction asOrdinalType(kind) {\n switch (kind) {\n case position:\n return \"point\";\n case color:\n return ordinalImplicit;\n default:\n return \"ordinal\";\n }\n}\n\nexport function isTemporalScale({type}) {\n return type === \"time\" || type === \"utc\";\n}\n\nexport function isOrdinalScale({type}) {\n return type === \"ordinal\" || type === \"point\" || type === \"band\" || type === ordinalImplicit;\n}\n\nexport function isThresholdScale({type}) {\n return type === \"threshold\";\n}\n\nfunction isBandScale({type}) {\n return type === \"point\" || type === \"band\";\n}\n\nexport function isDivergingScale({type}) {\n return /^diverging($|-)/.test(type);\n}\n\n// Certain marks have special behavior if a scale is collapsed, i.e. if the\n// domain is degenerate and represents only a single value such as [3, 3]; for\n// example, a rect will span the full extent of the chart along a collapsed\n// dimension (whereas a dot will simply be drawn in the center).\nexport function isCollapsed(scale) {\n if (scale === undefined) return true; // treat missing scale as collapsed\n const domain = scale.domain();\n const value = scale(domain[0]);\n for (let i = 1, n = domain.length; i < n; ++i) {\n if (scale(domain[i]) - value) {\n return false;\n }\n }\n return true;\n}\n\n// Mutates channel.value!\nfunction coerceType(channels, {domain, ...options}, coerceValues) {\n for (const c of channels) {\n if (c.value !== undefined) {\n c.value = coerceValues(c.value);\n }\n }\n return {\n domain: domain === undefined ? domain : coerceValues(domain),\n ...options\n };\n}\n\nfunction coerceSymbols(values) {\n return map(values, maybeSymbol);\n}\n\nexport function scale(options = {}) {\n let scale;\n for (const key in options) {\n if (!registry.has(key)) continue; // ignore unknown properties\n if (!isScaleOptions(options[key])) continue; // e.g., ignore {color: \"red\"}\n if (scale !== undefined) throw new Error(\"ambiguous scale definition; multiple scales found\");\n scale = exposeScale(normalizeScale(key, options[key]));\n }\n if (scale === undefined) throw new Error(\"invalid scale definition; no scale found\");\n return scale;\n}\n\nexport function exposeScales(scaleDescriptors) {\n return (key) => {\n if (!registry.has((key = `${key}`))) throw new Error(`unknown scale: ${key}`);\n return key in scaleDescriptors ? exposeScale(scaleDescriptors[key]) : undefined;\n };\n}\n\n// Note: axis- and legend-related properties (such as label, ticks and\n// tickFormat) are not included here as they do not affect the scale’s behavior.\nfunction exposeScale({scale, type, domain, range, interpolate, interval, transform, percent, pivot}) {\n if (type === \"identity\") return {type: \"identity\", apply: (d) => d, invert: (d) => d};\n const unknown = scale.unknown ? scale.unknown() : undefined;\n return {\n type,\n domain: slice(domain), // defensive copy\n ...(range !== undefined && {range: slice(range)}), // defensive copy\n ...(transform !== undefined && {transform}),\n ...(percent && {percent}), // only exposed if truthy\n ...(unknown !== undefined && {unknown}),\n ...(interval !== undefined && {interval}),\n\n // quantitative\n ...(interpolate !== undefined && {interpolate}),\n ...(scale.clamp && {clamp: scale.clamp()}),\n\n // diverging (always asymmetric; we never want to apply the symmetric transform twice)\n ...(pivot !== undefined && {pivot, symmetric: false}),\n\n // log, diverging-log\n ...(scale.base && {base: scale.base()}),\n\n // pow, diverging-pow\n ...(scale.exponent && {exponent: scale.exponent()}),\n\n // symlog, diverging-symlog\n ...(scale.constant && {constant: scale.constant()}),\n\n // band, point\n ...(scale.align && {align: scale.align(), round: scale.round()}),\n ...(scale.padding &&\n (scale.paddingInner\n ? {paddingInner: scale.paddingInner(), paddingOuter: scale.paddingOuter()}\n : {padding: scale.padding()})),\n ...(scale.bandwidth && {bandwidth: scale.bandwidth(), step: scale.step()}),\n\n // utilities\n apply: (t) => scale(t),\n ...(scale.invert && {invert: (t) => scale.invert(t)})\n };\n}\n","// @ts-ignore\nimport { scale } from '@observablehq/plot';\nimport { OptionsType } from './options/Options';\nimport { SCALE_BASE_OPACITY_COLOR } from './constant';\n\nimport type { SubDomain } from './index';\n\ntype ValueType = string | number | undefined;\n\nexport function normalizedScale(scaleOptions: OptionsType['scale']): any {\n try {\n const scaleType = Object.keys(scaleOptions!)[0];\n\n return scale({\n [scaleType]: {\n ...scaleOptions![scaleType as 'color' | 'opacity'],\n clamp: true,\n },\n });\n } catch (error) {\n return null;\n }\n}\n\nfunction scaleStyle(_scale: any, scaleOptions: OptionsType['scale']) {\n const styles: { fill?: Function; 'fill-opacity'?: Function } = {};\n\n if (scaleOptions!.hasOwnProperty('opacity')) {\n styles.fill = () =>\n // eslint-disable-next-line implicit-arrow-linebreak\n scaleOptions!.opacity!.baseColor || SCALE_BASE_OPACITY_COLOR;\n styles['fill-opacity'] = (d: ValueType) => _scale?.apply(d);\n } else {\n styles.fill = (d: ValueType) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n (typeof d === 'string' && d?.startsWith('#') ? d : _scale?.apply(d));\n }\n\n return styles;\n}\n\nexport function applyScaleStyle(\n elem: any,\n _scale: any,\n scaleOptions: OptionsType['scale'],\n keyname?: string,\n) {\n Object.entries(scaleStyle(_scale, scaleOptions)).forEach(([prop, val]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n elem.style(prop, (d: SubDomain | string) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n val(keyname ? (d as SubDomain)[keyname as keyof SubDomain] : d)));\n}\n","import isFunction from 'lodash-es/isFunction';\nimport { hcl } from 'd3-color';\nimport { normalizedScale, applyScaleStyle } from '../scale';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { SubDomain, Timestamp } from '../index';\n\nexport default class Populator {\n calendar: CalHeatmap;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n }\n\n populate(): void {\n const { calendar } = this;\n const { scale, subDomain } = calendar.options.options;\n const colorScale = normalizedScale(scale);\n\n calendar.calendarPainter\n .root!.selectAll('.ch-domain')\n .selectAll('svg')\n .selectAll('g')\n .data((d: Timestamp) => calendar.domainCollection.get(d) || [])\n .call((element: any) => {\n applyScaleStyle(element.select('rect'), colorScale, scale!, 'v');\n })\n .call((element: any) => {\n element\n .select('text')\n .attr('style', (d: SubDomain) => {\n const defaultColor =\n hcl(colorScale?.apply(d.v)).l > 60 ? '#000' : '#fff';\n let color = subDomain.color || (d.v ? defaultColor : null);\n\n if (isFunction(color)) {\n color = color(d.t, d.v, colorScale?.apply(d.v));\n }\n\n if (!color) {\n return null;\n }\n\n return `fill: ${color};`;\n })\n .text((d: SubDomain, i: number, nodes: any[]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n calendar.dateHelper.format(d.t, subDomain.label, d.v, nodes[i]));\n })\n .call(() => {\n calendar.eventEmitter.emit('fill');\n });\n }\n}\n","/**\n * Performs a\n * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * comparison between two values to determine if they are equivalent.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.eq(object, object);\n * // => true\n *\n * _.eq(object, other);\n * // => false\n *\n * _.eq('a', 'a');\n * // => true\n *\n * _.eq('a', Object('a'));\n * // => false\n *\n * _.eq(NaN, NaN);\n * // => true\n */\nfunction eq(value, other) {\n return value === other || (value !== value && other !== other);\n}\n\nexport default eq;\n","import eq from './eq.js';\n\n/**\n * Gets the index at which the `key` is found in `array` of key-value pairs.\n *\n * @private\n * @param {Array} array The array to inspect.\n * @param {*} key The key to search for.\n * @returns {number} Returns the index of the matched value, else `-1`.\n */\nfunction assocIndexOf(array, key) {\n var length = array.length;\n while (length--) {\n if (eq(array[length][0], key)) {\n return length;\n }\n }\n return -1;\n}\n\nexport default assocIndexOf;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/** Used for built-in method references. */\nvar arrayProto = Array.prototype;\n\n/** Built-in value references. */\nvar splice = arrayProto.splice;\n\n/**\n * Removes `key` and its value from the list cache.\n *\n * @private\n * @name delete\n * @memberOf ListCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction listCacheDelete(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n return false;\n }\n var lastIndex = data.length - 1;\n if (index == lastIndex) {\n data.pop();\n } else {\n splice.call(data, index, 1);\n }\n --this.size;\n return true;\n}\n\nexport default listCacheDelete;\n","import listCacheClear from './_listCacheClear.js';\nimport listCacheDelete from './_listCacheDelete.js';\nimport listCacheGet from './_listCacheGet.js';\nimport listCacheHas from './_listCacheHas.js';\nimport listCacheSet from './_listCacheSet.js';\n\n/**\n * Creates an list cache object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction ListCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `ListCache`.\nListCache.prototype.clear = listCacheClear;\nListCache.prototype['delete'] = listCacheDelete;\nListCache.prototype.get = listCacheGet;\nListCache.prototype.has = listCacheHas;\nListCache.prototype.set = listCacheSet;\n\nexport default ListCache;\n","/**\n * Removes all key-value entries from the list cache.\n *\n * @private\n * @name clear\n * @memberOf ListCache\n */\nfunction listCacheClear() {\n this.__data__ = [];\n this.size = 0;\n}\n\nexport default listCacheClear;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Gets the list cache value for `key`.\n *\n * @private\n * @name get\n * @memberOf ListCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction listCacheGet(key) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n return index < 0 ? undefined : data[index][1];\n}\n\nexport default listCacheGet;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Checks if a list cache value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf ListCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction listCacheHas(key) {\n return assocIndexOf(this.__data__, key) > -1;\n}\n\nexport default listCacheHas;\n","import assocIndexOf from './_assocIndexOf.js';\n\n/**\n * Sets the list cache `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf ListCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the list cache instance.\n */\nfunction listCacheSet(key, value) {\n var data = this.__data__,\n index = assocIndexOf(data, key);\n\n if (index < 0) {\n ++this.size;\n data.push([key, value]);\n } else {\n data[index][1] = value;\n }\n return this;\n}\n\nexport default listCacheSet;\n","import root from './_root.js';\n\n/** Used to detect overreaching core-js shims. */\nvar coreJsData = root['__core-js_shared__'];\n\nexport default coreJsData;\n","import coreJsData from './_coreJsData.js';\n\n/** Used to detect methods masquerading as native. */\nvar maskSrcKey = (function() {\n var uid = /[^.]+$/.exec(coreJsData && coreJsData.keys && coreJsData.keys.IE_PROTO || '');\n return uid ? ('Symbol(src)_1.' + uid) : '';\n}());\n\n/**\n * Checks if `func` has its source masked.\n *\n * @private\n * @param {Function} func The function to check.\n * @returns {boolean} Returns `true` if `func` is masked, else `false`.\n */\nfunction isMasked(func) {\n return !!maskSrcKey && (maskSrcKey in func);\n}\n\nexport default isMasked;\n","/** Used for built-in method references. */\nvar funcProto = Function.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/**\n * Converts `func` to its source code.\n *\n * @private\n * @param {Function} func The function to convert.\n * @returns {string} Returns the source code.\n */\nfunction toSource(func) {\n if (func != null) {\n try {\n return funcToString.call(func);\n } catch (e) {}\n try {\n return (func + '');\n } catch (e) {}\n }\n return '';\n}\n\nexport default toSource;\n","import isFunction from './isFunction.js';\nimport isMasked from './_isMasked.js';\nimport isObject from './isObject.js';\nimport toSource from './_toSource.js';\n\n/**\n * Used to match `RegExp`\n * [syntax characters](http://ecma-international.org/ecma-262/7.0/#sec-patterns).\n */\nvar reRegExpChar = /[\\\\^$.*+?()[\\]{}|]/g;\n\n/** Used to detect host constructors (Safari). */\nvar reIsHostCtor = /^\\[object .+?Constructor\\]$/;\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to detect if a method is native. */\nvar reIsNative = RegExp('^' +\n funcToString.call(hasOwnProperty).replace(reRegExpChar, '\\\\$&')\n .replace(/hasOwnProperty|(function).*?(?=\\\\\\()| for .+?(?=\\\\\\])/g, '$1.*?') + '$'\n);\n\n/**\n * The base implementation of `_.isNative` without bad shim checks.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a native function,\n * else `false`.\n */\nfunction baseIsNative(value) {\n if (!isObject(value) || isMasked(value)) {\n return false;\n }\n var pattern = isFunction(value) ? reIsNative : reIsHostCtor;\n return pattern.test(toSource(value));\n}\n\nexport default baseIsNative;\n","import baseIsNative from './_baseIsNative.js';\nimport getValue from './_getValue.js';\n\n/**\n * Gets the native function at `key` of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the method to get.\n * @returns {*} Returns the function if it's native, else `undefined`.\n */\nfunction getNative(object, key) {\n var value = getValue(object, key);\n return baseIsNative(value) ? value : undefined;\n}\n\nexport default getNative;\n","/**\n * Gets the value at `key` of `object`.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction getValue(object, key) {\n return object == null ? undefined : object[key];\n}\n\nexport default getValue;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Map = getNative(root, 'Map');\n\nexport default Map;\n","import getNative from './_getNative.js';\n\n/* Built-in method references that are verified to be native. */\nvar nativeCreate = getNative(Object, 'create');\n\nexport default nativeCreate;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Gets the hash value for `key`.\n *\n * @private\n * @name get\n * @memberOf Hash\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction hashGet(key) {\n var data = this.__data__;\n if (nativeCreate) {\n var result = data[key];\n return result === HASH_UNDEFINED ? undefined : result;\n }\n return hasOwnProperty.call(data, key) ? data[key] : undefined;\n}\n\nexport default hashGet;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Checks if a hash value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Hash\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction hashHas(key) {\n var data = this.__data__;\n return nativeCreate ? (data[key] !== undefined) : hasOwnProperty.call(data, key);\n}\n\nexport default hashHas;\n","import hashClear from './_hashClear.js';\nimport hashDelete from './_hashDelete.js';\nimport hashGet from './_hashGet.js';\nimport hashHas from './_hashHas.js';\nimport hashSet from './_hashSet.js';\n\n/**\n * Creates a hash object.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Hash(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `Hash`.\nHash.prototype.clear = hashClear;\nHash.prototype['delete'] = hashDelete;\nHash.prototype.get = hashGet;\nHash.prototype.has = hashHas;\nHash.prototype.set = hashSet;\n\nexport default Hash;\n","import isKeyable from './_isKeyable.js';\n\n/**\n * Gets the data for `map`.\n *\n * @private\n * @param {Object} map The map to query.\n * @param {string} key The reference key.\n * @returns {*} Returns the map data.\n */\nfunction getMapData(map, key) {\n var data = map.__data__;\n return isKeyable(key)\n ? data[typeof key == 'string' ? 'string' : 'hash']\n : data.map;\n}\n\nexport default getMapData;\n","/**\n * Checks if `value` is suitable for use as unique object key.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is suitable, else `false`.\n */\nfunction isKeyable(value) {\n var type = typeof value;\n return (type == 'string' || type == 'number' || type == 'symbol' || type == 'boolean')\n ? (value !== '__proto__')\n : (value === null);\n}\n\nexport default isKeyable;\n","import mapCacheClear from './_mapCacheClear.js';\nimport mapCacheDelete from './_mapCacheDelete.js';\nimport mapCacheGet from './_mapCacheGet.js';\nimport mapCacheHas from './_mapCacheHas.js';\nimport mapCacheSet from './_mapCacheSet.js';\n\n/**\n * Creates a map cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction MapCache(entries) {\n var index = -1,\n length = entries == null ? 0 : entries.length;\n\n this.clear();\n while (++index < length) {\n var entry = entries[index];\n this.set(entry[0], entry[1]);\n }\n}\n\n// Add methods to `MapCache`.\nMapCache.prototype.clear = mapCacheClear;\nMapCache.prototype['delete'] = mapCacheDelete;\nMapCache.prototype.get = mapCacheGet;\nMapCache.prototype.has = mapCacheHas;\nMapCache.prototype.set = mapCacheSet;\n\nexport default MapCache;\n","import nativeCreate from './_nativeCreate.js';\n\n/**\n * Removes all key-value entries from the hash.\n *\n * @private\n * @name clear\n * @memberOf Hash\n */\nfunction hashClear() {\n this.__data__ = nativeCreate ? nativeCreate(null) : {};\n this.size = 0;\n}\n\nexport default hashClear;\n","/**\n * Removes `key` and its value from the hash.\n *\n * @private\n * @name delete\n * @memberOf Hash\n * @param {Object} hash The hash to modify.\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction hashDelete(key) {\n var result = this.has(key) && delete this.__data__[key];\n this.size -= result ? 1 : 0;\n return result;\n}\n\nexport default hashDelete;\n","import nativeCreate from './_nativeCreate.js';\n\n/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Sets the hash `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Hash\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the hash instance.\n */\nfunction hashSet(key, value) {\n var data = this.__data__;\n this.size += this.has(key) ? 0 : 1;\n data[key] = (nativeCreate && value === undefined) ? HASH_UNDEFINED : value;\n return this;\n}\n\nexport default hashSet;\n","import Hash from './_Hash.js';\nimport ListCache from './_ListCache.js';\nimport Map from './_Map.js';\n\n/**\n * Removes all key-value entries from the map.\n *\n * @private\n * @name clear\n * @memberOf MapCache\n */\nfunction mapCacheClear() {\n this.size = 0;\n this.__data__ = {\n 'hash': new Hash,\n 'map': new (Map || ListCache),\n 'string': new Hash\n };\n}\n\nexport default mapCacheClear;\n","import getMapData from './_getMapData.js';\n\n/**\n * Removes `key` and its value from the map.\n *\n * @private\n * @name delete\n * @memberOf MapCache\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction mapCacheDelete(key) {\n var result = getMapData(this, key)['delete'](key);\n this.size -= result ? 1 : 0;\n return result;\n}\n\nexport default mapCacheDelete;\n","import getMapData from './_getMapData.js';\n\n/**\n * Gets the map value for `key`.\n *\n * @private\n * @name get\n * @memberOf MapCache\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction mapCacheGet(key) {\n return getMapData(this, key).get(key);\n}\n\nexport default mapCacheGet;\n","import getMapData from './_getMapData.js';\n\n/**\n * Checks if a map value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf MapCache\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction mapCacheHas(key) {\n return getMapData(this, key).has(key);\n}\n\nexport default mapCacheHas;\n","import getMapData from './_getMapData.js';\n\n/**\n * Sets the map `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf MapCache\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the map cache instance.\n */\nfunction mapCacheSet(key, value) {\n var data = getMapData(this, key),\n size = data.size;\n\n data.set(key, value);\n this.size += data.size == size ? 0 : 1;\n return this;\n}\n\nexport default mapCacheSet;\n","import ListCache from './_ListCache.js';\nimport stackClear from './_stackClear.js';\nimport stackDelete from './_stackDelete.js';\nimport stackGet from './_stackGet.js';\nimport stackHas from './_stackHas.js';\nimport stackSet from './_stackSet.js';\n\n/**\n * Creates a stack cache object to store key-value pairs.\n *\n * @private\n * @constructor\n * @param {Array} [entries] The key-value pairs to cache.\n */\nfunction Stack(entries) {\n var data = this.__data__ = new ListCache(entries);\n this.size = data.size;\n}\n\n// Add methods to `Stack`.\nStack.prototype.clear = stackClear;\nStack.prototype['delete'] = stackDelete;\nStack.prototype.get = stackGet;\nStack.prototype.has = stackHas;\nStack.prototype.set = stackSet;\n\nexport default Stack;\n","import ListCache from './_ListCache.js';\n\n/**\n * Removes all key-value entries from the stack.\n *\n * @private\n * @name clear\n * @memberOf Stack\n */\nfunction stackClear() {\n this.__data__ = new ListCache;\n this.size = 0;\n}\n\nexport default stackClear;\n","/**\n * Removes `key` and its value from the stack.\n *\n * @private\n * @name delete\n * @memberOf Stack\n * @param {string} key The key of the value to remove.\n * @returns {boolean} Returns `true` if the entry was removed, else `false`.\n */\nfunction stackDelete(key) {\n var data = this.__data__,\n result = data['delete'](key);\n\n this.size = data.size;\n return result;\n}\n\nexport default stackDelete;\n","/**\n * Gets the stack value for `key`.\n *\n * @private\n * @name get\n * @memberOf Stack\n * @param {string} key The key of the value to get.\n * @returns {*} Returns the entry value.\n */\nfunction stackGet(key) {\n return this.__data__.get(key);\n}\n\nexport default stackGet;\n","/**\n * Checks if a stack value for `key` exists.\n *\n * @private\n * @name has\n * @memberOf Stack\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction stackHas(key) {\n return this.__data__.has(key);\n}\n\nexport default stackHas;\n","import ListCache from './_ListCache.js';\nimport Map from './_Map.js';\nimport MapCache from './_MapCache.js';\n\n/** Used as the size to enable large array optimizations. */\nvar LARGE_ARRAY_SIZE = 200;\n\n/**\n * Sets the stack `key` to `value`.\n *\n * @private\n * @name set\n * @memberOf Stack\n * @param {string} key The key of the value to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns the stack cache instance.\n */\nfunction stackSet(key, value) {\n var data = this.__data__;\n if (data instanceof ListCache) {\n var pairs = data.__data__;\n if (!Map || (pairs.length < LARGE_ARRAY_SIZE - 1)) {\n pairs.push([key, value]);\n this.size = ++data.size;\n return this;\n }\n data = this.__data__ = new MapCache(pairs);\n }\n data.set(key, value);\n this.size = data.size;\n return this;\n}\n\nexport default stackSet;\n","import getNative from './_getNative.js';\n\nvar defineProperty = (function() {\n try {\n var func = getNative(Object, 'defineProperty');\n func({}, '', {});\n return func;\n } catch (e) {}\n}());\n\nexport default defineProperty;\n","import defineProperty from './_defineProperty.js';\n\n/**\n * The base implementation of `assignValue` and `assignMergeValue` without\n * value checks.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction baseAssignValue(object, key, value) {\n if (key == '__proto__' && defineProperty) {\n defineProperty(object, key, {\n 'configurable': true,\n 'enumerable': true,\n 'value': value,\n 'writable': true\n });\n } else {\n object[key] = value;\n }\n}\n\nexport default baseAssignValue;\n","import baseAssignValue from './_baseAssignValue.js';\nimport eq from './eq.js';\n\n/**\n * This function is like `assignValue` except that it doesn't assign\n * `undefined` values.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignMergeValue(object, key, value) {\n if ((value !== undefined && !eq(object[key], value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n}\n\nexport default assignMergeValue;\n","import createBaseFor from './_createBaseFor.js';\n\n/**\n * The base implementation of `baseForOwn` which iterates over `object`\n * properties returned by `keysFunc` and invokes `iteratee` for each property.\n * Iteratee functions may exit iteration early by explicitly returning `false`.\n *\n * @private\n * @param {Object} object The object to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @returns {Object} Returns `object`.\n */\nvar baseFor = createBaseFor();\n\nexport default baseFor;\n","/**\n * Creates a base function for methods like `_.forIn` and `_.forOwn`.\n *\n * @private\n * @param {boolean} [fromRight] Specify iterating from right to left.\n * @returns {Function} Returns the new base function.\n */\nfunction createBaseFor(fromRight) {\n return function(object, iteratee, keysFunc) {\n var index = -1,\n iterable = Object(object),\n props = keysFunc(object),\n length = props.length;\n\n while (length--) {\n var key = props[fromRight ? length : ++index];\n if (iteratee(iterable[key], key, iterable) === false) {\n break;\n }\n }\n return object;\n };\n}\n\nexport default createBaseFor;\n","import root from './_root.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined,\n allocUnsafe = Buffer ? Buffer.allocUnsafe : undefined;\n\n/**\n * Creates a clone of `buffer`.\n *\n * @private\n * @param {Buffer} buffer The buffer to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Buffer} Returns the cloned buffer.\n */\nfunction cloneBuffer(buffer, isDeep) {\n if (isDeep) {\n return buffer.slice();\n }\n var length = buffer.length,\n result = allocUnsafe ? allocUnsafe(length) : new buffer.constructor(length);\n\n buffer.copy(result);\n return result;\n}\n\nexport default cloneBuffer;\n","import root from './_root.js';\n\n/** Built-in value references. */\nvar Uint8Array = root.Uint8Array;\n\nexport default Uint8Array;\n","import cloneArrayBuffer from './_cloneArrayBuffer.js';\n\n/**\n * Creates a clone of `typedArray`.\n *\n * @private\n * @param {Object} typedArray The typed array to clone.\n * @param {boolean} [isDeep] Specify a deep clone.\n * @returns {Object} Returns the cloned typed array.\n */\nfunction cloneTypedArray(typedArray, isDeep) {\n var buffer = isDeep ? cloneArrayBuffer(typedArray.buffer) : typedArray.buffer;\n return new typedArray.constructor(buffer, typedArray.byteOffset, typedArray.length);\n}\n\nexport default cloneTypedArray;\n","import Uint8Array from './_Uint8Array.js';\n\n/**\n * Creates a clone of `arrayBuffer`.\n *\n * @private\n * @param {ArrayBuffer} arrayBuffer The array buffer to clone.\n * @returns {ArrayBuffer} Returns the cloned array buffer.\n */\nfunction cloneArrayBuffer(arrayBuffer) {\n var result = new arrayBuffer.constructor(arrayBuffer.byteLength);\n new Uint8Array(result).set(new Uint8Array(arrayBuffer));\n return result;\n}\n\nexport default cloneArrayBuffer;\n","import isObject from './isObject.js';\n\n/** Built-in value references. */\nvar objectCreate = Object.create;\n\n/**\n * The base implementation of `_.create` without support for assigning\n * properties to the created object.\n *\n * @private\n * @param {Object} proto The object to inherit from.\n * @returns {Object} Returns the new object.\n */\nvar baseCreate = (function() {\n function object() {}\n return function(proto) {\n if (!isObject(proto)) {\n return {};\n }\n if (objectCreate) {\n return objectCreate(proto);\n }\n object.prototype = proto;\n var result = new object;\n object.prototype = undefined;\n return result;\n };\n}());\n\nexport default baseCreate;\n","/**\n * Creates a unary function that invokes `func` with its argument transformed.\n *\n * @private\n * @param {Function} func The function to wrap.\n * @param {Function} transform The argument transform.\n * @returns {Function} Returns the new function.\n */\nfunction overArg(func, transform) {\n return function(arg) {\n return func(transform(arg));\n };\n}\n\nexport default overArg;\n","import overArg from './_overArg.js';\n\n/** Built-in value references. */\nvar getPrototype = overArg(Object.getPrototypeOf, Object);\n\nexport default getPrototype;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/**\n * Checks if `value` is likely a prototype object.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a prototype, else `false`.\n */\nfunction isPrototype(value) {\n var Ctor = value && value.constructor,\n proto = (typeof Ctor == 'function' && Ctor.prototype) || objectProto;\n\n return value === proto;\n}\n\nexport default isPrototype;\n","/**\n * Checks if `value` is object-like. A value is object-like if it's not `null`\n * and has a `typeof` result of \"object\".\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is object-like, else `false`.\n * @example\n *\n * _.isObjectLike({});\n * // => true\n *\n * _.isObjectLike([1, 2, 3]);\n * // => true\n *\n * _.isObjectLike(_.noop);\n * // => false\n *\n * _.isObjectLike(null);\n * // => false\n */\nfunction isObjectLike(value) {\n return value != null && typeof value == 'object';\n}\n\nexport default isObjectLike;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]';\n\n/**\n * The base implementation of `_.isArguments`.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n */\nfunction baseIsArguments(value) {\n return isObjectLike(value) && baseGetTag(value) == argsTag;\n}\n\nexport default baseIsArguments;\n","import baseIsArguments from './_baseIsArguments.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/**\n * Checks if `value` is likely an `arguments` object.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an `arguments` object,\n * else `false`.\n * @example\n *\n * _.isArguments(function() { return arguments; }());\n * // => true\n *\n * _.isArguments([1, 2, 3]);\n * // => false\n */\nvar isArguments = baseIsArguments(function() { return arguments; }()) ? baseIsArguments : function(value) {\n return isObjectLike(value) && hasOwnProperty.call(value, 'callee') &&\n !propertyIsEnumerable.call(value, 'callee');\n};\n\nexport default isArguments;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/**\n * Checks if `value` is a valid array-like length.\n *\n * **Note:** This method is loosely based on\n * [`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a valid length, else `false`.\n * @example\n *\n * _.isLength(3);\n * // => true\n *\n * _.isLength(Number.MIN_VALUE);\n * // => false\n *\n * _.isLength(Infinity);\n * // => false\n *\n * _.isLength('3');\n * // => false\n */\nfunction isLength(value) {\n return typeof value == 'number' &&\n value > -1 && value % 1 == 0 && value <= MAX_SAFE_INTEGER;\n}\n\nexport default isLength;\n","import isFunction from './isFunction.js';\nimport isLength from './isLength.js';\n\n/**\n * Checks if `value` is array-like. A value is considered array-like if it's\n * not a function and has a `value.length` that's an integer greater than or\n * equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is array-like, else `false`.\n * @example\n *\n * _.isArrayLike([1, 2, 3]);\n * // => true\n *\n * _.isArrayLike(document.body.children);\n * // => true\n *\n * _.isArrayLike('abc');\n * // => true\n *\n * _.isArrayLike(_.noop);\n * // => false\n */\nfunction isArrayLike(value) {\n return value != null && isLength(value.length) && !isFunction(value);\n}\n\nexport default isArrayLike;\n","import root from './_root.js';\nimport stubFalse from './stubFalse.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Built-in value references. */\nvar Buffer = moduleExports ? root.Buffer : undefined;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeIsBuffer = Buffer ? Buffer.isBuffer : undefined;\n\n/**\n * Checks if `value` is a buffer.\n *\n * @static\n * @memberOf _\n * @since 4.3.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a buffer, else `false`.\n * @example\n *\n * _.isBuffer(new Buffer(2));\n * // => true\n *\n * _.isBuffer(new Uint8Array(2));\n * // => false\n */\nvar isBuffer = nativeIsBuffer || stubFalse;\n\nexport default isBuffer;\n","/**\n * This method returns `false`.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {boolean} Returns `false`.\n * @example\n *\n * _.times(2, _.stubFalse);\n * // => [false, false]\n */\nfunction stubFalse() {\n return false;\n}\n\nexport default stubFalse;\n","import baseGetTag from './_baseGetTag.js';\nimport getPrototype from './_getPrototype.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar funcProto = Function.prototype,\n objectProto = Object.prototype;\n\n/** Used to resolve the decompiled source of functions. */\nvar funcToString = funcProto.toString;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/** Used to infer the `Object` constructor. */\nvar objectCtorString = funcToString.call(Object);\n\n/**\n * Checks if `value` is a plain object, that is, an object created by the\n * `Object` constructor or one with a `[[Prototype]]` of `null`.\n *\n * @static\n * @memberOf _\n * @since 0.8.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * }\n *\n * _.isPlainObject(new Foo);\n * // => false\n *\n * _.isPlainObject([1, 2, 3]);\n * // => false\n *\n * _.isPlainObject({ 'x': 0, 'y': 0 });\n * // => true\n *\n * _.isPlainObject(Object.create(null));\n * // => true\n */\nfunction isPlainObject(value) {\n if (!isObjectLike(value) || baseGetTag(value) != objectTag) {\n return false;\n }\n var proto = getPrototype(value);\n if (proto === null) {\n return true;\n }\n var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;\n return typeof Ctor == 'function' && Ctor instanceof Ctor &&\n funcToString.call(Ctor) == objectCtorString;\n}\n\nexport default isPlainObject;\n","import baseGetTag from './_baseGetTag.js';\nimport isLength from './isLength.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n funcTag = '[object Function]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n objectTag = '[object Object]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n weakMapTag = '[object WeakMap]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]',\n float32Tag = '[object Float32Array]',\n float64Tag = '[object Float64Array]',\n int8Tag = '[object Int8Array]',\n int16Tag = '[object Int16Array]',\n int32Tag = '[object Int32Array]',\n uint8Tag = '[object Uint8Array]',\n uint8ClampedTag = '[object Uint8ClampedArray]',\n uint16Tag = '[object Uint16Array]',\n uint32Tag = '[object Uint32Array]';\n\n/** Used to identify `toStringTag` values of typed arrays. */\nvar typedArrayTags = {};\ntypedArrayTags[float32Tag] = typedArrayTags[float64Tag] =\ntypedArrayTags[int8Tag] = typedArrayTags[int16Tag] =\ntypedArrayTags[int32Tag] = typedArrayTags[uint8Tag] =\ntypedArrayTags[uint8ClampedTag] = typedArrayTags[uint16Tag] =\ntypedArrayTags[uint32Tag] = true;\ntypedArrayTags[argsTag] = typedArrayTags[arrayTag] =\ntypedArrayTags[arrayBufferTag] = typedArrayTags[boolTag] =\ntypedArrayTags[dataViewTag] = typedArrayTags[dateTag] =\ntypedArrayTags[errorTag] = typedArrayTags[funcTag] =\ntypedArrayTags[mapTag] = typedArrayTags[numberTag] =\ntypedArrayTags[objectTag] = typedArrayTags[regexpTag] =\ntypedArrayTags[setTag] = typedArrayTags[stringTag] =\ntypedArrayTags[weakMapTag] = false;\n\n/**\n * The base implementation of `_.isTypedArray` without Node.js optimizations.\n *\n * @private\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n */\nfunction baseIsTypedArray(value) {\n return isObjectLike(value) &&\n isLength(value.length) && !!typedArrayTags[baseGetTag(value)];\n}\n\nexport default baseIsTypedArray;\n","import freeGlobal from './_freeGlobal.js';\n\n/** Detect free variable `exports`. */\nvar freeExports = typeof exports == 'object' && exports && !exports.nodeType && exports;\n\n/** Detect free variable `module`. */\nvar freeModule = freeExports && typeof module == 'object' && module && !module.nodeType && module;\n\n/** Detect the popular CommonJS extension `module.exports`. */\nvar moduleExports = freeModule && freeModule.exports === freeExports;\n\n/** Detect free variable `process` from Node.js. */\nvar freeProcess = moduleExports && freeGlobal.process;\n\n/** Used to access faster Node.js helpers. */\nvar nodeUtil = (function() {\n try {\n // Use `util.types` for Node.js 10+.\n var types = freeModule && freeModule.require && freeModule.require('util').types;\n\n if (types) {\n return types;\n }\n\n // Legacy `process.binding('util')` for Node.js < 10.\n return freeProcess && freeProcess.binding && freeProcess.binding('util');\n } catch (e) {}\n}());\n\nexport default nodeUtil;\n","/**\n * The base implementation of `_.unary` without support for storing metadata.\n *\n * @private\n * @param {Function} func The function to cap arguments for.\n * @returns {Function} Returns the new capped function.\n */\nfunction baseUnary(func) {\n return function(value) {\n return func(value);\n };\n}\n\nexport default baseUnary;\n","import baseIsTypedArray from './_baseIsTypedArray.js';\nimport baseUnary from './_baseUnary.js';\nimport nodeUtil from './_nodeUtil.js';\n\n/* Node.js helper references. */\nvar nodeIsTypedArray = nodeUtil && nodeUtil.isTypedArray;\n\n/**\n * Checks if `value` is classified as a typed array.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a typed array, else `false`.\n * @example\n *\n * _.isTypedArray(new Uint8Array);\n * // => true\n *\n * _.isTypedArray([]);\n * // => false\n */\nvar isTypedArray = nodeIsTypedArray ? baseUnary(nodeIsTypedArray) : baseIsTypedArray;\n\nexport default isTypedArray;\n","/**\n * Gets the value at `key`, unless `key` is \"__proto__\" or \"constructor\".\n *\n * @private\n * @param {Object} object The object to query.\n * @param {string} key The key of the property to get.\n * @returns {*} Returns the property value.\n */\nfunction safeGet(object, key) {\n if (key === 'constructor' && typeof object[key] === 'function') {\n return;\n }\n\n if (key == '__proto__') {\n return;\n }\n\n return object[key];\n}\n\nexport default safeGet;\n","import baseAssignValue from './_baseAssignValue.js';\nimport eq from './eq.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Assigns `value` to `key` of `object` if the existing value is not equivalent\n * using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)\n * for equality comparisons.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {string} key The key of the property to assign.\n * @param {*} value The value to assign.\n */\nfunction assignValue(object, key, value) {\n var objValue = object[key];\n if (!(hasOwnProperty.call(object, key) && eq(objValue, value)) ||\n (value === undefined && !(key in object))) {\n baseAssignValue(object, key, value);\n }\n}\n\nexport default assignValue;\n","/** Used as references for various `Number` constants. */\nvar MAX_SAFE_INTEGER = 9007199254740991;\n\n/** Used to detect unsigned integer values. */\nvar reIsUint = /^(?:0|[1-9]\\d*)$/;\n\n/**\n * Checks if `value` is a valid array-like index.\n *\n * @private\n * @param {*} value The value to check.\n * @param {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.\n * @returns {boolean} Returns `true` if `value` is a valid index, else `false`.\n */\nfunction isIndex(value, length) {\n var type = typeof value;\n length = length == null ? MAX_SAFE_INTEGER : length;\n\n return !!length &&\n (type == 'number' ||\n (type != 'symbol' && reIsUint.test(value))) &&\n (value > -1 && value % 1 == 0 && value < length);\n}\n\nexport default isIndex;\n","import baseTimes from './_baseTimes.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isIndex from './_isIndex.js';\nimport isTypedArray from './isTypedArray.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * Creates an array of the enumerable property names of the array-like `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @param {boolean} inherited Specify returning inherited property names.\n * @returns {Array} Returns the array of property names.\n */\nfunction arrayLikeKeys(value, inherited) {\n var isArr = isArray(value),\n isArg = !isArr && isArguments(value),\n isBuff = !isArr && !isArg && isBuffer(value),\n isType = !isArr && !isArg && !isBuff && isTypedArray(value),\n skipIndexes = isArr || isArg || isBuff || isType,\n result = skipIndexes ? baseTimes(value.length, String) : [],\n length = result.length;\n\n for (var key in value) {\n if ((inherited || hasOwnProperty.call(value, key)) &&\n !(skipIndexes && (\n // Safari 9 has enumerable `arguments.length` in strict mode.\n key == 'length' ||\n // Node.js 0.10 has enumerable non-index properties on buffers.\n (isBuff && (key == 'offset' || key == 'parent')) ||\n // PhantomJS 2 has enumerable non-index properties on typed arrays.\n (isType && (key == 'buffer' || key == 'byteLength' || key == 'byteOffset')) ||\n // Skip index properties.\n isIndex(key, length)\n ))) {\n result.push(key);\n }\n }\n return result;\n}\n\nexport default arrayLikeKeys;\n","/**\n * The base implementation of `_.times` without support for iteratee shorthands\n * or max array length checks.\n *\n * @private\n * @param {number} n The number of times to invoke `iteratee`.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the array of results.\n */\nfunction baseTimes(n, iteratee) {\n var index = -1,\n result = Array(n);\n\n while (++index < n) {\n result[index] = iteratee(index);\n }\n return result;\n}\n\nexport default baseTimes;\n","import isObject from './isObject.js';\nimport isPrototype from './_isPrototype.js';\nimport nativeKeysIn from './_nativeKeysIn.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeysIn(object) {\n if (!isObject(object)) {\n return nativeKeysIn(object);\n }\n var isProto = isPrototype(object),\n result = [];\n\n for (var key in object) {\n if (!(key == 'constructor' && (isProto || !hasOwnProperty.call(object, key)))) {\n result.push(key);\n }\n }\n return result;\n}\n\nexport default baseKeysIn;\n","/**\n * This function is like\n * [`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * except that it includes inherited enumerable properties.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction nativeKeysIn(object) {\n var result = [];\n if (object != null) {\n for (var key in Object(object)) {\n result.push(key);\n }\n }\n return result;\n}\n\nexport default nativeKeysIn;\n","import arrayLikeKeys from './_arrayLikeKeys.js';\nimport baseKeysIn from './_baseKeysIn.js';\nimport isArrayLike from './isArrayLike.js';\n\n/**\n * Creates an array of the own and inherited enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keysIn(new Foo);\n * // => ['a', 'b', 'c'] (iteration order is not guaranteed)\n */\nfunction keysIn(object) {\n return isArrayLike(object) ? arrayLikeKeys(object, true) : baseKeysIn(object);\n}\n\nexport default keysIn;\n","import copyObject from './_copyObject.js';\nimport keysIn from './keysIn.js';\n\n/**\n * Converts `value` to a plain object flattening inherited enumerable string\n * keyed properties of `value` to own properties of the plain object.\n *\n * @static\n * @memberOf _\n * @since 3.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {Object} Returns the converted plain object.\n * @example\n *\n * function Foo() {\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.assign({ 'a': 1 }, new Foo);\n * // => { 'a': 1, 'b': 2 }\n *\n * _.assign({ 'a': 1 }, _.toPlainObject(new Foo));\n * // => { 'a': 1, 'b': 2, 'c': 3 }\n */\nfunction toPlainObject(value) {\n return copyObject(value, keysIn(value));\n}\n\nexport default toPlainObject;\n","import assignValue from './_assignValue.js';\nimport baseAssignValue from './_baseAssignValue.js';\n\n/**\n * Copies properties of `source` to `object`.\n *\n * @private\n * @param {Object} source The object to copy properties from.\n * @param {Array} props The property identifiers to copy.\n * @param {Object} [object={}] The object to copy properties to.\n * @param {Function} [customizer] The function to customize copied values.\n * @returns {Object} Returns `object`.\n */\nfunction copyObject(source, props, object, customizer) {\n var isNew = !object;\n object || (object = {});\n\n var index = -1,\n length = props.length;\n\n while (++index < length) {\n var key = props[index];\n\n var newValue = customizer\n ? customizer(object[key], source[key], key, object, source)\n : undefined;\n\n if (newValue === undefined) {\n newValue = source[key];\n }\n if (isNew) {\n baseAssignValue(object, key, newValue);\n } else {\n assignValue(object, key, newValue);\n }\n }\n return object;\n}\n\nexport default copyObject;\n","import assignMergeValue from './_assignMergeValue.js';\nimport cloneBuffer from './_cloneBuffer.js';\nimport cloneTypedArray from './_cloneTypedArray.js';\nimport copyArray from './_copyArray.js';\nimport initCloneObject from './_initCloneObject.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isArrayLikeObject from './isArrayLikeObject.js';\nimport isBuffer from './isBuffer.js';\nimport isFunction from './isFunction.js';\nimport isObject from './isObject.js';\nimport isPlainObject from './isPlainObject.js';\nimport isTypedArray from './isTypedArray.js';\nimport safeGet from './_safeGet.js';\nimport toPlainObject from './toPlainObject.js';\n\n/**\n * A specialized version of `baseMerge` for arrays and objects which performs\n * deep merges and tracks traversed objects enabling objects with circular\n * references to be merged.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {string} key The key of the value to merge.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} mergeFunc The function to merge values.\n * @param {Function} [customizer] The function to customize assigned values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\nfunction baseMergeDeep(object, source, key, srcIndex, mergeFunc, customizer, stack) {\n var objValue = safeGet(object, key),\n srcValue = safeGet(source, key),\n stacked = stack.get(srcValue);\n\n if (stacked) {\n assignMergeValue(object, key, stacked);\n return;\n }\n var newValue = customizer\n ? customizer(objValue, srcValue, (key + ''), object, source, stack)\n : undefined;\n\n var isCommon = newValue === undefined;\n\n if (isCommon) {\n var isArr = isArray(srcValue),\n isBuff = !isArr && isBuffer(srcValue),\n isTyped = !isArr && !isBuff && isTypedArray(srcValue);\n\n newValue = srcValue;\n if (isArr || isBuff || isTyped) {\n if (isArray(objValue)) {\n newValue = objValue;\n }\n else if (isArrayLikeObject(objValue)) {\n newValue = copyArray(objValue);\n }\n else if (isBuff) {\n isCommon = false;\n newValue = cloneBuffer(srcValue, true);\n }\n else if (isTyped) {\n isCommon = false;\n newValue = cloneTypedArray(srcValue, true);\n }\n else {\n newValue = [];\n }\n }\n else if (isPlainObject(srcValue) || isArguments(srcValue)) {\n newValue = objValue;\n if (isArguments(objValue)) {\n newValue = toPlainObject(objValue);\n }\n else if (!isObject(objValue) || isFunction(objValue)) {\n newValue = initCloneObject(srcValue);\n }\n }\n else {\n isCommon = false;\n }\n }\n if (isCommon) {\n // Recursively merge objects and arrays (susceptible to call stack limits).\n stack.set(srcValue, newValue);\n mergeFunc(newValue, srcValue, srcIndex, customizer, stack);\n stack['delete'](srcValue);\n }\n assignMergeValue(object, key, newValue);\n}\n\nexport default baseMergeDeep;\n","import isArrayLike from './isArrayLike.js';\nimport isObjectLike from './isObjectLike.js';\n\n/**\n * This method is like `_.isArrayLike` except that it also checks if `value`\n * is an object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is an array-like object,\n * else `false`.\n * @example\n *\n * _.isArrayLikeObject([1, 2, 3]);\n * // => true\n *\n * _.isArrayLikeObject(document.body.children);\n * // => true\n *\n * _.isArrayLikeObject('abc');\n * // => false\n *\n * _.isArrayLikeObject(_.noop);\n * // => false\n */\nfunction isArrayLikeObject(value) {\n return isObjectLike(value) && isArrayLike(value);\n}\n\nexport default isArrayLikeObject;\n","/**\n * Copies the values of `source` to `array`.\n *\n * @private\n * @param {Array} source The array to copy values from.\n * @param {Array} [array=[]] The array to copy values to.\n * @returns {Array} Returns `array`.\n */\nfunction copyArray(source, array) {\n var index = -1,\n length = source.length;\n\n array || (array = Array(length));\n while (++index < length) {\n array[index] = source[index];\n }\n return array;\n}\n\nexport default copyArray;\n","import baseCreate from './_baseCreate.js';\nimport getPrototype from './_getPrototype.js';\nimport isPrototype from './_isPrototype.js';\n\n/**\n * Initializes an object clone.\n *\n * @private\n * @param {Object} object The object to clone.\n * @returns {Object} Returns the initialized clone.\n */\nfunction initCloneObject(object) {\n return (typeof object.constructor == 'function' && !isPrototype(object))\n ? baseCreate(getPrototype(object))\n : {};\n}\n\nexport default initCloneObject;\n","import Stack from './_Stack.js';\nimport assignMergeValue from './_assignMergeValue.js';\nimport baseFor from './_baseFor.js';\nimport baseMergeDeep from './_baseMergeDeep.js';\nimport isObject from './isObject.js';\nimport keysIn from './keysIn.js';\nimport safeGet from './_safeGet.js';\n\n/**\n * The base implementation of `_.merge` without support for multiple sources.\n *\n * @private\n * @param {Object} object The destination object.\n * @param {Object} source The source object.\n * @param {number} srcIndex The index of `source`.\n * @param {Function} [customizer] The function to customize merged values.\n * @param {Object} [stack] Tracks traversed source values and their merged\n * counterparts.\n */\nfunction baseMerge(object, source, srcIndex, customizer, stack) {\n if (object === source) {\n return;\n }\n baseFor(source, function(srcValue, key) {\n stack || (stack = new Stack);\n if (isObject(srcValue)) {\n baseMergeDeep(object, source, key, srcIndex, baseMerge, customizer, stack);\n }\n else {\n var newValue = customizer\n ? customizer(safeGet(object, key), srcValue, (key + ''), object, source, stack)\n : undefined;\n\n if (newValue === undefined) {\n newValue = srcValue;\n }\n assignMergeValue(object, key, newValue);\n }\n }, keysIn);\n}\n\nexport default baseMerge;\n","/**\n * This method returns the first argument it receives.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Util\n * @param {*} value Any value.\n * @returns {*} Returns `value`.\n * @example\n *\n * var object = { 'a': 1 };\n *\n * console.log(_.identity(object) === object);\n * // => true\n */\nfunction identity(value) {\n return value;\n}\n\nexport default identity;\n","import apply from './_apply.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeMax = Math.max;\n\n/**\n * A specialized version of `baseRest` which transforms the rest array.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @param {Function} transform The rest array transform.\n * @returns {Function} Returns the new function.\n */\nfunction overRest(func, start, transform) {\n start = nativeMax(start === undefined ? (func.length - 1) : start, 0);\n return function() {\n var args = arguments,\n index = -1,\n length = nativeMax(args.length - start, 0),\n array = Array(length);\n\n while (++index < length) {\n array[index] = args[start + index];\n }\n index = -1;\n var otherArgs = Array(start + 1);\n while (++index < start) {\n otherArgs[index] = args[index];\n }\n otherArgs[start] = transform(array);\n return apply(func, this, otherArgs);\n };\n}\n\nexport default overRest;\n","import constant from './constant.js';\nimport defineProperty from './_defineProperty.js';\nimport identity from './identity.js';\n\n/**\n * The base implementation of `setToString` without support for hot loop shorting.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar baseSetToString = !defineProperty ? identity : function(func, string) {\n return defineProperty(func, 'toString', {\n 'configurable': true,\n 'enumerable': false,\n 'value': constant(string),\n 'writable': true\n });\n};\n\nexport default baseSetToString;\n","/**\n * Creates a function that returns `value`.\n *\n * @static\n * @memberOf _\n * @since 2.4.0\n * @category Util\n * @param {*} value The value to return from the new function.\n * @returns {Function} Returns the new constant function.\n * @example\n *\n * var objects = _.times(2, _.constant({ 'a': 1 }));\n *\n * console.log(objects);\n * // => [{ 'a': 1 }, { 'a': 1 }]\n *\n * console.log(objects[0] === objects[1]);\n * // => true\n */\nfunction constant(value) {\n return function() {\n return value;\n };\n}\n\nexport default constant;\n","/** Used to detect hot functions by number of calls within a span of milliseconds. */\nvar HOT_COUNT = 800,\n HOT_SPAN = 16;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeNow = Date.now;\n\n/**\n * Creates a function that'll short out and invoke `identity` instead\n * of `func` when it's called `HOT_COUNT` or more times in `HOT_SPAN`\n * milliseconds.\n *\n * @private\n * @param {Function} func The function to restrict.\n * @returns {Function} Returns the new shortable function.\n */\nfunction shortOut(func) {\n var count = 0,\n lastCalled = 0;\n\n return function() {\n var stamp = nativeNow(),\n remaining = HOT_SPAN - (stamp - lastCalled);\n\n lastCalled = stamp;\n if (remaining > 0) {\n if (++count >= HOT_COUNT) {\n return arguments[0];\n }\n } else {\n count = 0;\n }\n return func.apply(undefined, arguments);\n };\n}\n\nexport default shortOut;\n","import baseSetToString from './_baseSetToString.js';\nimport shortOut from './_shortOut.js';\n\n/**\n * Sets the `toString` method of `func` to return `string`.\n *\n * @private\n * @param {Function} func The function to modify.\n * @param {Function} string The `toString` result.\n * @returns {Function} Returns `func`.\n */\nvar setToString = shortOut(baseSetToString);\n\nexport default setToString;\n","import identity from './identity.js';\nimport overRest from './_overRest.js';\nimport setToString from './_setToString.js';\n\n/**\n * The base implementation of `_.rest` which doesn't validate or coerce arguments.\n *\n * @private\n * @param {Function} func The function to apply a rest parameter to.\n * @param {number} [start=func.length-1] The start position of the rest parameter.\n * @returns {Function} Returns the new function.\n */\nfunction baseRest(func, start) {\n return setToString(overRest(func, start, identity), func + '');\n}\n\nexport default baseRest;\n","/**\n * A faster alternative to `Function#apply`, this function invokes `func`\n * with the `this` binding of `thisArg` and the arguments of `args`.\n *\n * @private\n * @param {Function} func The function to invoke.\n * @param {*} thisArg The `this` binding of `func`.\n * @param {Array} args The arguments to invoke `func` with.\n * @returns {*} Returns the result of `func`.\n */\nfunction apply(func, thisArg, args) {\n switch (args.length) {\n case 0: return func.call(thisArg);\n case 1: return func.call(thisArg, args[0]);\n case 2: return func.call(thisArg, args[0], args[1]);\n case 3: return func.call(thisArg, args[0], args[1], args[2]);\n }\n return func.apply(thisArg, args);\n}\n\nexport default apply;\n","import baseMerge from './_baseMerge.js';\nimport createAssigner from './_createAssigner.js';\n\n/**\n * This method is like `_.merge` except that it accepts `customizer` which\n * is invoked to produce the merged values of the destination and source\n * properties. If `customizer` returns `undefined`, merging is handled by the\n * method instead. The `customizer` is invoked with six arguments:\n * (objValue, srcValue, key, object, source, stack).\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Object\n * @param {Object} object The destination object.\n * @param {...Object} sources The source objects.\n * @param {Function} customizer The function to customize assigned values.\n * @returns {Object} Returns `object`.\n * @example\n *\n * function customizer(objValue, srcValue) {\n * if (_.isArray(objValue)) {\n * return objValue.concat(srcValue);\n * }\n * }\n *\n * var object = { 'a': [1], 'b': [2] };\n * var other = { 'a': [3], 'b': [4] };\n *\n * _.mergeWith(object, other, customizer);\n * // => { 'a': [1, 3], 'b': [2, 4] }\n */\nvar mergeWith = createAssigner(function(object, source, srcIndex, customizer) {\n baseMerge(object, source, srcIndex, customizer);\n});\n\nexport default mergeWith;\n","import baseRest from './_baseRest.js';\nimport isIterateeCall from './_isIterateeCall.js';\n\n/**\n * Creates a function like `_.assign`.\n *\n * @private\n * @param {Function} assigner The function to assign values.\n * @returns {Function} Returns the new assigner function.\n */\nfunction createAssigner(assigner) {\n return baseRest(function(object, sources) {\n var index = -1,\n length = sources.length,\n customizer = length > 1 ? sources[length - 1] : undefined,\n guard = length > 2 ? sources[2] : undefined;\n\n customizer = (assigner.length > 3 && typeof customizer == 'function')\n ? (length--, customizer)\n : undefined;\n\n if (guard && isIterateeCall(sources[0], sources[1], guard)) {\n customizer = length < 3 ? undefined : customizer;\n length = 1;\n }\n object = Object(object);\n while (++index < length) {\n var source = sources[index];\n if (source) {\n assigner(object, source, index, customizer);\n }\n }\n return object;\n });\n}\n\nexport default createAssigner;\n","import eq from './eq.js';\nimport isArrayLike from './isArrayLike.js';\nimport isIndex from './_isIndex.js';\nimport isObject from './isObject.js';\n\n/**\n * Checks if the given arguments are from an iteratee call.\n *\n * @private\n * @param {*} value The potential iteratee value argument.\n * @param {*} index The potential iteratee index or key argument.\n * @param {*} object The potential iteratee object argument.\n * @returns {boolean} Returns `true` if the arguments are from an iteratee call,\n * else `false`.\n */\nfunction isIterateeCall(value, index, object) {\n if (!isObject(object)) {\n return false;\n }\n var type = typeof index;\n if (type == 'number'\n ? (isArrayLike(object) && isIndex(index, object.length))\n : (type == 'string' && index in object)\n ) {\n return eq(object[index], value);\n }\n return false;\n}\n\nexport default isIterateeCall;\n","import MapCache from './_MapCache.js';\nimport setCacheAdd from './_setCacheAdd.js';\nimport setCacheHas from './_setCacheHas.js';\n\n/**\n *\n * Creates an array cache object to store unique values.\n *\n * @private\n * @constructor\n * @param {Array} [values] The values to cache.\n */\nfunction SetCache(values) {\n var index = -1,\n length = values == null ? 0 : values.length;\n\n this.__data__ = new MapCache;\n while (++index < length) {\n this.add(values[index]);\n }\n}\n\n// Add methods to `SetCache`.\nSetCache.prototype.add = SetCache.prototype.push = setCacheAdd;\nSetCache.prototype.has = setCacheHas;\n\nexport default SetCache;\n","/**\n * A specialized version of `_.some` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {boolean} Returns `true` if any element passes the predicate check,\n * else `false`.\n */\nfunction arraySome(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length;\n\n while (++index < length) {\n if (predicate(array[index], index, array)) {\n return true;\n }\n }\n return false;\n}\n\nexport default arraySome;\n","/** Used to stand-in for `undefined` hash values. */\nvar HASH_UNDEFINED = '__lodash_hash_undefined__';\n\n/**\n * Adds `value` to the array cache.\n *\n * @private\n * @name add\n * @memberOf SetCache\n * @alias push\n * @param {*} value The value to cache.\n * @returns {Object} Returns the cache instance.\n */\nfunction setCacheAdd(value) {\n this.__data__.set(value, HASH_UNDEFINED);\n return this;\n}\n\nexport default setCacheAdd;\n","/**\n * Checks if `value` is in the array cache.\n *\n * @private\n * @name has\n * @memberOf SetCache\n * @param {*} value The value to search for.\n * @returns {number} Returns `true` if `value` is found, else `false`.\n */\nfunction setCacheHas(value) {\n return this.__data__.has(value);\n}\n\nexport default setCacheHas;\n","import SetCache from './_SetCache.js';\nimport arraySome from './_arraySome.js';\nimport cacheHas from './_cacheHas.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/**\n * A specialized version of `baseIsEqualDeep` for arrays with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Array} array The array to compare.\n * @param {Array} other The other array to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `array` and `other` objects.\n * @returns {boolean} Returns `true` if the arrays are equivalent, else `false`.\n */\nfunction equalArrays(array, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n arrLength = array.length,\n othLength = other.length;\n\n if (arrLength != othLength && !(isPartial && othLength > arrLength)) {\n return false;\n }\n // Check that cyclic values are equal.\n var arrStacked = stack.get(array);\n var othStacked = stack.get(other);\n if (arrStacked && othStacked) {\n return arrStacked == other && othStacked == array;\n }\n var index = -1,\n result = true,\n seen = (bitmask & COMPARE_UNORDERED_FLAG) ? new SetCache : undefined;\n\n stack.set(array, other);\n stack.set(other, array);\n\n // Ignore non-index properties.\n while (++index < arrLength) {\n var arrValue = array[index],\n othValue = other[index];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, arrValue, index, other, array, stack)\n : customizer(arrValue, othValue, index, array, other, stack);\n }\n if (compared !== undefined) {\n if (compared) {\n continue;\n }\n result = false;\n break;\n }\n // Recursively compare arrays (susceptible to call stack limits).\n if (seen) {\n if (!arraySome(other, function(othValue, othIndex) {\n if (!cacheHas(seen, othIndex) &&\n (arrValue === othValue || equalFunc(arrValue, othValue, bitmask, customizer, stack))) {\n return seen.push(othIndex);\n }\n })) {\n result = false;\n break;\n }\n } else if (!(\n arrValue === othValue ||\n equalFunc(arrValue, othValue, bitmask, customizer, stack)\n )) {\n result = false;\n break;\n }\n }\n stack['delete'](array);\n stack['delete'](other);\n return result;\n}\n\nexport default equalArrays;\n","/**\n * Checks if a `cache` value for `key` exists.\n *\n * @private\n * @param {Object} cache The cache to query.\n * @param {string} key The key of the entry to check.\n * @returns {boolean} Returns `true` if an entry for `key` exists, else `false`.\n */\nfunction cacheHas(cache, key) {\n return cache.has(key);\n}\n\nexport default cacheHas;\n","/**\n * Converts `map` to its key-value pairs.\n *\n * @private\n * @param {Object} map The map to convert.\n * @returns {Array} Returns the key-value pairs.\n */\nfunction mapToArray(map) {\n var index = -1,\n result = Array(map.size);\n\n map.forEach(function(value, key) {\n result[++index] = [key, value];\n });\n return result;\n}\n\nexport default mapToArray;\n","/**\n * Converts `set` to an array of its values.\n *\n * @private\n * @param {Object} set The set to convert.\n * @returns {Array} Returns the values.\n */\nfunction setToArray(set) {\n var index = -1,\n result = Array(set.size);\n\n set.forEach(function(value) {\n result[++index] = value;\n });\n return result;\n}\n\nexport default setToArray;\n","import Symbol from './_Symbol.js';\nimport Uint8Array from './_Uint8Array.js';\nimport eq from './eq.js';\nimport equalArrays from './_equalArrays.js';\nimport mapToArray from './_mapToArray.js';\nimport setToArray from './_setToArray.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1,\n COMPARE_UNORDERED_FLAG = 2;\n\n/** `Object#toString` result references. */\nvar boolTag = '[object Boolean]',\n dateTag = '[object Date]',\n errorTag = '[object Error]',\n mapTag = '[object Map]',\n numberTag = '[object Number]',\n regexpTag = '[object RegExp]',\n setTag = '[object Set]',\n stringTag = '[object String]',\n symbolTag = '[object Symbol]';\n\nvar arrayBufferTag = '[object ArrayBuffer]',\n dataViewTag = '[object DataView]';\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolValueOf = symbolProto ? symbolProto.valueOf : undefined;\n\n/**\n * A specialized version of `baseIsEqualDeep` for comparing objects of\n * the same `toStringTag`.\n *\n * **Note:** This function only supports comparing values with tags of\n * `Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {string} tag The `toStringTag` of the objects to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) {\n switch (tag) {\n case dataViewTag:\n if ((object.byteLength != other.byteLength) ||\n (object.byteOffset != other.byteOffset)) {\n return false;\n }\n object = object.buffer;\n other = other.buffer;\n\n case arrayBufferTag:\n if ((object.byteLength != other.byteLength) ||\n !equalFunc(new Uint8Array(object), new Uint8Array(other))) {\n return false;\n }\n return true;\n\n case boolTag:\n case dateTag:\n case numberTag:\n // Coerce booleans to `1` or `0` and dates to milliseconds.\n // Invalid dates are coerced to `NaN`.\n return eq(+object, +other);\n\n case errorTag:\n return object.name == other.name && object.message == other.message;\n\n case regexpTag:\n case stringTag:\n // Coerce regexes to strings and treat strings, primitives and objects,\n // as equal. See http://www.ecma-international.org/ecma-262/7.0/#sec-regexp.prototype.tostring\n // for more details.\n return object == (other + '');\n\n case mapTag:\n var convert = mapToArray;\n\n case setTag:\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG;\n convert || (convert = setToArray);\n\n if (object.size != other.size && !isPartial) {\n return false;\n }\n // Assume cyclic values are equal.\n var stacked = stack.get(object);\n if (stacked) {\n return stacked == other;\n }\n bitmask |= COMPARE_UNORDERED_FLAG;\n\n // Recursively compare objects (susceptible to call stack limits).\n stack.set(object, other);\n var result = equalArrays(convert(object), convert(other), bitmask, customizer, equalFunc, stack);\n stack['delete'](object);\n return result;\n\n case symbolTag:\n if (symbolValueOf) {\n return symbolValueOf.call(object) == symbolValueOf.call(other);\n }\n }\n return false;\n}\n\nexport default equalByTag;\n","import arrayFilter from './_arrayFilter.js';\nimport stubArray from './stubArray.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Built-in value references. */\nvar propertyIsEnumerable = objectProto.propertyIsEnumerable;\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeGetSymbols = Object.getOwnPropertySymbols;\n\n/**\n * Creates an array of the own enumerable symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of symbols.\n */\nvar getSymbols = !nativeGetSymbols ? stubArray : function(object) {\n if (object == null) {\n return [];\n }\n object = Object(object);\n return arrayFilter(nativeGetSymbols(object), function(symbol) {\n return propertyIsEnumerable.call(object, symbol);\n });\n};\n\nexport default getSymbols;\n","/**\n * A specialized version of `_.filter` for arrays without support for\n * iteratee shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} predicate The function invoked per iteration.\n * @returns {Array} Returns the new filtered array.\n */\nfunction arrayFilter(array, predicate) {\n var index = -1,\n length = array == null ? 0 : array.length,\n resIndex = 0,\n result = [];\n\n while (++index < length) {\n var value = array[index];\n if (predicate(value, index, array)) {\n result[resIndex++] = value;\n }\n }\n return result;\n}\n\nexport default arrayFilter;\n","/**\n * This method returns a new empty array.\n *\n * @static\n * @memberOf _\n * @since 4.13.0\n * @category Util\n * @returns {Array} Returns the new empty array.\n * @example\n *\n * var arrays = _.times(2, _.stubArray);\n *\n * console.log(arrays);\n * // => [[], []]\n *\n * console.log(arrays[0] === arrays[1]);\n * // => false\n */\nfunction stubArray() {\n return [];\n}\n\nexport default stubArray;\n","import overArg from './_overArg.js';\n\n/* Built-in method references for those with the same name as other `lodash` methods. */\nvar nativeKeys = overArg(Object.keys, Object);\n\nexport default nativeKeys;\n","import isPrototype from './_isPrototype.js';\nimport nativeKeys from './_nativeKeys.js';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.keys` which doesn't treat sparse arrays as dense.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n */\nfunction baseKeys(object) {\n if (!isPrototype(object)) {\n return nativeKeys(object);\n }\n var result = [];\n for (var key in Object(object)) {\n if (hasOwnProperty.call(object, key) && key != 'constructor') {\n result.push(key);\n }\n }\n return result;\n}\n\nexport default baseKeys;\n","import arrayLikeKeys from './_arrayLikeKeys.js';\nimport baseKeys from './_baseKeys.js';\nimport isArrayLike from './isArrayLike.js';\n\n/**\n * Creates an array of the own enumerable property names of `object`.\n *\n * **Note:** Non-object values are coerced to objects. See the\n * [ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)\n * for more details.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names.\n * @example\n *\n * function Foo() {\n * this.a = 1;\n * this.b = 2;\n * }\n *\n * Foo.prototype.c = 3;\n *\n * _.keys(new Foo);\n * // => ['a', 'b'] (iteration order is not guaranteed)\n *\n * _.keys('hi');\n * // => ['0', '1']\n */\nfunction keys(object) {\n return isArrayLike(object) ? arrayLikeKeys(object) : baseKeys(object);\n}\n\nexport default keys;\n","import baseGetAllKeys from './_baseGetAllKeys.js';\nimport getSymbols from './_getSymbols.js';\nimport keys from './keys.js';\n\n/**\n * Creates an array of own enumerable property names and symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction getAllKeys(object) {\n return baseGetAllKeys(object, keys, getSymbols);\n}\n\nexport default getAllKeys;\n","import arrayPush from './_arrayPush.js';\nimport isArray from './isArray.js';\n\n/**\n * The base implementation of `getAllKeys` and `getAllKeysIn` which uses\n * `keysFunc` and `symbolsFunc` to get the enumerable property names and\n * symbols of `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Function} keysFunc The function to get the keys of `object`.\n * @param {Function} symbolsFunc The function to get the symbols of `object`.\n * @returns {Array} Returns the array of property names and symbols.\n */\nfunction baseGetAllKeys(object, keysFunc, symbolsFunc) {\n var result = keysFunc(object);\n return isArray(object) ? result : arrayPush(result, symbolsFunc(object));\n}\n\nexport default baseGetAllKeys;\n","/**\n * Appends the elements of `values` to `array`.\n *\n * @private\n * @param {Array} array The array to modify.\n * @param {Array} values The values to append.\n * @returns {Array} Returns `array`.\n */\nfunction arrayPush(array, values) {\n var index = -1,\n length = values.length,\n offset = array.length;\n\n while (++index < length) {\n array[offset + index] = values[index];\n }\n return array;\n}\n\nexport default arrayPush;\n","import getAllKeys from './_getAllKeys.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqualDeep` for objects with support for\n * partial deep comparisons.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} stack Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction equalObjects(object, other, bitmask, customizer, equalFunc, stack) {\n var isPartial = bitmask & COMPARE_PARTIAL_FLAG,\n objProps = getAllKeys(object),\n objLength = objProps.length,\n othProps = getAllKeys(other),\n othLength = othProps.length;\n\n if (objLength != othLength && !isPartial) {\n return false;\n }\n var index = objLength;\n while (index--) {\n var key = objProps[index];\n if (!(isPartial ? key in other : hasOwnProperty.call(other, key))) {\n return false;\n }\n }\n // Check that cyclic values are equal.\n var objStacked = stack.get(object);\n var othStacked = stack.get(other);\n if (objStacked && othStacked) {\n return objStacked == other && othStacked == object;\n }\n var result = true;\n stack.set(object, other);\n stack.set(other, object);\n\n var skipCtor = isPartial;\n while (++index < objLength) {\n key = objProps[index];\n var objValue = object[key],\n othValue = other[key];\n\n if (customizer) {\n var compared = isPartial\n ? customizer(othValue, objValue, key, other, object, stack)\n : customizer(objValue, othValue, key, object, other, stack);\n }\n // Recursively compare objects (susceptible to call stack limits).\n if (!(compared === undefined\n ? (objValue === othValue || equalFunc(objValue, othValue, bitmask, customizer, stack))\n : compared\n )) {\n result = false;\n break;\n }\n skipCtor || (skipCtor = key == 'constructor');\n }\n if (result && !skipCtor) {\n var objCtor = object.constructor,\n othCtor = other.constructor;\n\n // Non `Object` object instances with different constructors are not equal.\n if (objCtor != othCtor &&\n ('constructor' in object && 'constructor' in other) &&\n !(typeof objCtor == 'function' && objCtor instanceof objCtor &&\n typeof othCtor == 'function' && othCtor instanceof othCtor)) {\n result = false;\n }\n }\n stack['delete'](object);\n stack['delete'](other);\n return result;\n}\n\nexport default equalObjects;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar DataView = getNative(root, 'DataView');\n\nexport default DataView;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Promise = getNative(root, 'Promise');\n\nexport default Promise;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar Set = getNative(root, 'Set');\n\nexport default Set;\n","import getNative from './_getNative.js';\nimport root from './_root.js';\n\n/* Built-in method references that are verified to be native. */\nvar WeakMap = getNative(root, 'WeakMap');\n\nexport default WeakMap;\n","import DataView from './_DataView.js';\nimport Map from './_Map.js';\nimport Promise from './_Promise.js';\nimport Set from './_Set.js';\nimport WeakMap from './_WeakMap.js';\nimport baseGetTag from './_baseGetTag.js';\nimport toSource from './_toSource.js';\n\n/** `Object#toString` result references. */\nvar mapTag = '[object Map]',\n objectTag = '[object Object]',\n promiseTag = '[object Promise]',\n setTag = '[object Set]',\n weakMapTag = '[object WeakMap]';\n\nvar dataViewTag = '[object DataView]';\n\n/** Used to detect maps, sets, and weakmaps. */\nvar dataViewCtorString = toSource(DataView),\n mapCtorString = toSource(Map),\n promiseCtorString = toSource(Promise),\n setCtorString = toSource(Set),\n weakMapCtorString = toSource(WeakMap);\n\n/**\n * Gets the `toStringTag` of `value`.\n *\n * @private\n * @param {*} value The value to query.\n * @returns {string} Returns the `toStringTag`.\n */\nvar getTag = baseGetTag;\n\n// Fallback for data views, maps, sets, and weak maps in IE 11 and promises in Node.js < 6.\nif ((DataView && getTag(new DataView(new ArrayBuffer(1))) != dataViewTag) ||\n (Map && getTag(new Map) != mapTag) ||\n (Promise && getTag(Promise.resolve()) != promiseTag) ||\n (Set && getTag(new Set) != setTag) ||\n (WeakMap && getTag(new WeakMap) != weakMapTag)) {\n getTag = function(value) {\n var result = baseGetTag(value),\n Ctor = result == objectTag ? value.constructor : undefined,\n ctorString = Ctor ? toSource(Ctor) : '';\n\n if (ctorString) {\n switch (ctorString) {\n case dataViewCtorString: return dataViewTag;\n case mapCtorString: return mapTag;\n case promiseCtorString: return promiseTag;\n case setCtorString: return setTag;\n case weakMapCtorString: return weakMapTag;\n }\n }\n return result;\n };\n}\n\nexport default getTag;\n","import Stack from './_Stack.js';\nimport equalArrays from './_equalArrays.js';\nimport equalByTag from './_equalByTag.js';\nimport equalObjects from './_equalObjects.js';\nimport getTag from './_getTag.js';\nimport isArray from './isArray.js';\nimport isBuffer from './isBuffer.js';\nimport isTypedArray from './isTypedArray.js';\n\n/** Used to compose bitmasks for value comparisons. */\nvar COMPARE_PARTIAL_FLAG = 1;\n\n/** `Object#toString` result references. */\nvar argsTag = '[object Arguments]',\n arrayTag = '[object Array]',\n objectTag = '[object Object]';\n\n/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * A specialized version of `baseIsEqual` for arrays and objects which performs\n * deep comparisons and tracks traversed objects enabling objects with circular\n * references to be compared.\n *\n * @private\n * @param {Object} object The object to compare.\n * @param {Object} other The other object to compare.\n * @param {number} bitmask The bitmask flags. See `baseIsEqual` for more details.\n * @param {Function} customizer The function to customize comparisons.\n * @param {Function} equalFunc The function to determine equivalents of values.\n * @param {Object} [stack] Tracks traversed `object` and `other` objects.\n * @returns {boolean} Returns `true` if the objects are equivalent, else `false`.\n */\nfunction baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) {\n var objIsArr = isArray(object),\n othIsArr = isArray(other),\n objTag = objIsArr ? arrayTag : getTag(object),\n othTag = othIsArr ? arrayTag : getTag(other);\n\n objTag = objTag == argsTag ? objectTag : objTag;\n othTag = othTag == argsTag ? objectTag : othTag;\n\n var objIsObj = objTag == objectTag,\n othIsObj = othTag == objectTag,\n isSameTag = objTag == othTag;\n\n if (isSameTag && isBuffer(object)) {\n if (!isBuffer(other)) {\n return false;\n }\n objIsArr = true;\n objIsObj = false;\n }\n if (isSameTag && !objIsObj) {\n stack || (stack = new Stack);\n return (objIsArr || isTypedArray(object))\n ? equalArrays(object, other, bitmask, customizer, equalFunc, stack)\n : equalByTag(object, other, objTag, bitmask, customizer, equalFunc, stack);\n }\n if (!(bitmask & COMPARE_PARTIAL_FLAG)) {\n var objIsWrapped = objIsObj && hasOwnProperty.call(object, '__wrapped__'),\n othIsWrapped = othIsObj && hasOwnProperty.call(other, '__wrapped__');\n\n if (objIsWrapped || othIsWrapped) {\n var objUnwrapped = objIsWrapped ? object.value() : object,\n othUnwrapped = othIsWrapped ? other.value() : other;\n\n stack || (stack = new Stack);\n return equalFunc(objUnwrapped, othUnwrapped, bitmask, customizer, stack);\n }\n }\n if (!isSameTag) {\n return false;\n }\n stack || (stack = new Stack);\n return equalObjects(object, other, bitmask, customizer, equalFunc, stack);\n}\n\nexport default baseIsEqualDeep;\n","import baseIsEqualDeep from './_baseIsEqualDeep.js';\nimport isObjectLike from './isObjectLike.js';\n\n/**\n * The base implementation of `_.isEqual` which supports partial comparisons\n * and tracks traversed objects.\n *\n * @private\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @param {boolean} bitmask The bitmask flags.\n * 1 - Unordered comparison\n * 2 - Partial comparison\n * @param {Function} [customizer] The function to customize comparisons.\n * @param {Object} [stack] Tracks traversed `value` and `other` objects.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n */\nfunction baseIsEqual(value, other, bitmask, customizer, stack) {\n if (value === other) {\n return true;\n }\n if (value == null || other == null || (!isObjectLike(value) && !isObjectLike(other))) {\n return value !== value && other !== other;\n }\n return baseIsEqualDeep(value, other, bitmask, customizer, baseIsEqual, stack);\n}\n\nexport default baseIsEqual;\n","import baseIsEqual from './_baseIsEqual.js';\n\n/**\n * Performs a deep comparison between two values to determine if they are\n * equivalent.\n *\n * **Note:** This method supports comparing arrays, array buffers, booleans,\n * date objects, error objects, maps, numbers, `Object` objects, regexes,\n * sets, strings, symbols, and typed arrays. `Object` objects are compared\n * by their own, not inherited, enumerable properties. Functions and DOM\n * nodes are compared by strict equality, i.e. `===`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Lang\n * @param {*} value The value to compare.\n * @param {*} other The other value to compare.\n * @returns {boolean} Returns `true` if the values are equivalent, else `false`.\n * @example\n *\n * var object = { 'a': 1 };\n * var other = { 'a': 1 };\n *\n * _.isEqual(object, other);\n * // => true\n *\n * object === other;\n * // => false\n */\nfunction isEqual(value, other) {\n return baseIsEqual(value, other);\n}\n\nexport default isEqual;\n","/** Used for built-in method references. */\nvar objectProto = Object.prototype;\n\n/** Used to check objects for own properties. */\nvar hasOwnProperty = objectProto.hasOwnProperty;\n\n/**\n * The base implementation of `_.has` without support for deep paths.\n *\n * @private\n * @param {Object} [object] The object to query.\n * @param {Array|string} key The key to check.\n * @returns {boolean} Returns `true` if `key` exists, else `false`.\n */\nfunction baseHas(object, key) {\n return object != null && hasOwnProperty.call(object, key);\n}\n\nexport default baseHas;\n","import baseGetTag from './_baseGetTag.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar symbolTag = '[object Symbol]';\n\n/**\n * Checks if `value` is classified as a `Symbol` primitive or object.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a symbol, else `false`.\n * @example\n *\n * _.isSymbol(Symbol.iterator);\n * // => true\n *\n * _.isSymbol('abc');\n * // => false\n */\nfunction isSymbol(value) {\n return typeof value == 'symbol' ||\n (isObjectLike(value) && baseGetTag(value) == symbolTag);\n}\n\nexport default isSymbol;\n","import isArray from './isArray.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used to match property names within property paths. */\nvar reIsDeepProp = /\\.|\\[(?:[^[\\]]*|([\"'])(?:(?!\\1)[^\\\\]|\\\\.)*?\\1)\\]/,\n reIsPlainProp = /^\\w*$/;\n\n/**\n * Checks if `value` is a property name and not a property path.\n *\n * @private\n * @param {*} value The value to check.\n * @param {Object} [object] The object to query keys on.\n * @returns {boolean} Returns `true` if `value` is a property name, else `false`.\n */\nfunction isKey(value, object) {\n if (isArray(value)) {\n return false;\n }\n var type = typeof value;\n if (type == 'number' || type == 'symbol' || type == 'boolean' ||\n value == null || isSymbol(value)) {\n return true;\n }\n return reIsPlainProp.test(value) || !reIsDeepProp.test(value) ||\n (object != null && value in Object(object));\n}\n\nexport default isKey;\n","import MapCache from './_MapCache.js';\n\n/** Error message constants. */\nvar FUNC_ERROR_TEXT = 'Expected a function';\n\n/**\n * Creates a function that memoizes the result of `func`. If `resolver` is\n * provided, it determines the cache key for storing the result based on the\n * arguments provided to the memoized function. By default, the first argument\n * provided to the memoized function is used as the map cache key. The `func`\n * is invoked with the `this` binding of the memoized function.\n *\n * **Note:** The cache is exposed as the `cache` property on the memoized\n * function. Its creation may be customized by replacing the `_.memoize.Cache`\n * constructor with one whose instances implement the\n * [`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)\n * method interface of `clear`, `delete`, `get`, `has`, and `set`.\n *\n * @static\n * @memberOf _\n * @since 0.1.0\n * @category Function\n * @param {Function} func The function to have its output memoized.\n * @param {Function} [resolver] The function to resolve the cache key.\n * @returns {Function} Returns the new memoized function.\n * @example\n *\n * var object = { 'a': 1, 'b': 2 };\n * var other = { 'c': 3, 'd': 4 };\n *\n * var values = _.memoize(_.values);\n * values(object);\n * // => [1, 2]\n *\n * values(other);\n * // => [3, 4]\n *\n * object.a = 2;\n * values(object);\n * // => [1, 2]\n *\n * // Modify the result cache.\n * values.cache.set(object, ['a', 'b']);\n * values(object);\n * // => ['a', 'b']\n *\n * // Replace `_.memoize.Cache`.\n * _.memoize.Cache = WeakMap;\n */\nfunction memoize(func, resolver) {\n if (typeof func != 'function' || (resolver != null && typeof resolver != 'function')) {\n throw new TypeError(FUNC_ERROR_TEXT);\n }\n var memoized = function() {\n var args = arguments,\n key = resolver ? resolver.apply(this, args) : args[0],\n cache = memoized.cache;\n\n if (cache.has(key)) {\n return cache.get(key);\n }\n var result = func.apply(this, args);\n memoized.cache = cache.set(key, result) || cache;\n return result;\n };\n memoized.cache = new (memoize.Cache || MapCache);\n return memoized;\n}\n\n// Expose `MapCache`.\nmemoize.Cache = MapCache;\n\nexport default memoize;\n","import memoizeCapped from './_memoizeCapped.js';\n\n/** Used to match property names within property paths. */\nvar rePropName = /[^.[\\]]+|\\[(?:(-?\\d+(?:\\.\\d+)?)|([\"'])((?:(?!\\2)[^\\\\]|\\\\.)*?)\\2)\\]|(?=(?:\\.|\\[\\])(?:\\.|\\[\\]|$))/g;\n\n/** Used to match backslashes in property paths. */\nvar reEscapeChar = /\\\\(\\\\)?/g;\n\n/**\n * Converts `string` to a property path array.\n *\n * @private\n * @param {string} string The string to convert.\n * @returns {Array} Returns the property path array.\n */\nvar stringToPath = memoizeCapped(function(string) {\n var result = [];\n if (string.charCodeAt(0) === 46 /* . */) {\n result.push('');\n }\n string.replace(rePropName, function(match, number, quote, subString) {\n result.push(quote ? subString.replace(reEscapeChar, '$1') : (number || match));\n });\n return result;\n});\n\nexport default stringToPath;\n","import memoize from './memoize.js';\n\n/** Used as the maximum memoize cache size. */\nvar MAX_MEMOIZE_SIZE = 500;\n\n/**\n * A specialized version of `_.memoize` which clears the memoized function's\n * cache when it exceeds `MAX_MEMOIZE_SIZE`.\n *\n * @private\n * @param {Function} func The function to have its output memoized.\n * @returns {Function} Returns the new memoized function.\n */\nfunction memoizeCapped(func) {\n var result = memoize(func, function(key) {\n if (cache.size === MAX_MEMOIZE_SIZE) {\n cache.clear();\n }\n return key;\n });\n\n var cache = result.cache;\n return result;\n}\n\nexport default memoizeCapped;\n","import Symbol from './_Symbol.js';\nimport arrayMap from './_arrayMap.js';\nimport isArray from './isArray.js';\nimport isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/** Used to convert symbols to primitives and strings. */\nvar symbolProto = Symbol ? Symbol.prototype : undefined,\n symbolToString = symbolProto ? symbolProto.toString : undefined;\n\n/**\n * The base implementation of `_.toString` which doesn't convert nullish\n * values to empty strings.\n *\n * @private\n * @param {*} value The value to process.\n * @returns {string} Returns the string.\n */\nfunction baseToString(value) {\n // Exit early for strings to avoid a performance hit in some environments.\n if (typeof value == 'string') {\n return value;\n }\n if (isArray(value)) {\n // Recursively convert values (susceptible to call stack limits).\n return arrayMap(value, baseToString) + '';\n }\n if (isSymbol(value)) {\n return symbolToString ? symbolToString.call(value) : '';\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nexport default baseToString;\n","/**\n * A specialized version of `_.map` for arrays without support for iteratee\n * shorthands.\n *\n * @private\n * @param {Array} [array] The array to iterate over.\n * @param {Function} iteratee The function invoked per iteration.\n * @returns {Array} Returns the new mapped array.\n */\nfunction arrayMap(array, iteratee) {\n var index = -1,\n length = array == null ? 0 : array.length,\n result = Array(length);\n\n while (++index < length) {\n result[index] = iteratee(array[index], index, array);\n }\n return result;\n}\n\nexport default arrayMap;\n","import isArray from './isArray.js';\nimport isKey from './_isKey.js';\nimport stringToPath from './_stringToPath.js';\nimport toString from './toString.js';\n\n/**\n * Casts `value` to a path array if it's not one.\n *\n * @private\n * @param {*} value The value to inspect.\n * @param {Object} [object] The object to query keys on.\n * @returns {Array} Returns the cast property path array.\n */\nfunction castPath(value, object) {\n if (isArray(value)) {\n return value;\n }\n return isKey(value, object) ? [value] : stringToPath(toString(value));\n}\n\nexport default castPath;\n","import baseToString from './_baseToString.js';\n\n/**\n * Converts `value` to a string. An empty string is returned for `null`\n * and `undefined` values. The sign of `-0` is preserved.\n *\n * @static\n * @memberOf _\n * @since 4.0.0\n * @category Lang\n * @param {*} value The value to convert.\n * @returns {string} Returns the converted string.\n * @example\n *\n * _.toString(null);\n * // => ''\n *\n * _.toString(-0);\n * // => '-0'\n *\n * _.toString([1, 2, 3]);\n * // => '1,2,3'\n */\nfunction toString(value) {\n return value == null ? '' : baseToString(value);\n}\n\nexport default toString;\n","import isSymbol from './isSymbol.js';\n\n/** Used as references for various `Number` constants. */\nvar INFINITY = 1 / 0;\n\n/**\n * Converts `value` to a string key if it's not a string or symbol.\n *\n * @private\n * @param {*} value The value to inspect.\n * @returns {string|symbol} Returns the key.\n */\nfunction toKey(value) {\n if (typeof value == 'string' || isSymbol(value)) {\n return value;\n }\n var result = (value + '');\n return (result == '0' && (1 / value) == -INFINITY) ? '-0' : result;\n}\n\nexport default toKey;\n","import baseHas from './_baseHas.js';\nimport hasPath from './_hasPath.js';\n\n/**\n * Checks if `path` is a direct property of `object`.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n * @example\n *\n * var object = { 'a': { 'b': 2 } };\n * var other = _.create({ 'a': _.create({ 'b': 2 }) });\n *\n * _.has(object, 'a');\n * // => true\n *\n * _.has(object, 'a.b');\n * // => true\n *\n * _.has(object, ['a', 'b']);\n * // => true\n *\n * _.has(other, 'a');\n * // => false\n */\nfunction has(object, path) {\n return object != null && hasPath(object, path, baseHas);\n}\n\nexport default has;\n","import castPath from './_castPath.js';\nimport isArguments from './isArguments.js';\nimport isArray from './isArray.js';\nimport isIndex from './_isIndex.js';\nimport isLength from './isLength.js';\nimport toKey from './_toKey.js';\n\n/**\n * Checks if `path` exists on `object`.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path to check.\n * @param {Function} hasFunc The function to check properties.\n * @returns {boolean} Returns `true` if `path` exists, else `false`.\n */\nfunction hasPath(object, path, hasFunc) {\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n result = false;\n\n while (++index < length) {\n var key = toKey(path[index]);\n if (!(result = object != null && hasFunc(object, key))) {\n break;\n }\n object = object[key];\n }\n if (result || ++index != length) {\n return result;\n }\n length = object == null ? 0 : object.length;\n return !!length && isLength(length) && isIndex(key, length) &&\n (isArray(object) || isArguments(object));\n}\n\nexport default hasPath;\n","import baseGet from './_baseGet.js';\n\n/**\n * Gets the value at `path` of `object`. If the resolved value is\n * `undefined`, the `defaultValue` is returned in its place.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @param {*} [defaultValue] The value returned for `undefined` resolved values.\n * @returns {*} Returns the resolved value.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.get(object, 'a[0].b.c');\n * // => 3\n *\n * _.get(object, ['a', '0', 'b', 'c']);\n * // => 3\n *\n * _.get(object, 'a.b.c', 'default');\n * // => 'default'\n */\nfunction get(object, path, defaultValue) {\n var result = object == null ? undefined : baseGet(object, path);\n return result === undefined ? defaultValue : result;\n}\n\nexport default get;\n","import castPath from './_castPath.js';\nimport toKey from './_toKey.js';\n\n/**\n * The base implementation of `_.get` without support for default values.\n *\n * @private\n * @param {Object} object The object to query.\n * @param {Array|string} path The path of the property to get.\n * @returns {*} Returns the resolved value.\n */\nfunction baseGet(object, path) {\n path = castPath(path, object);\n\n var index = 0,\n length = path.length;\n\n while (object != null && index < length) {\n object = object[toKey(path[index++])];\n }\n return (index && index == length) ? object : undefined;\n}\n\nexport default baseGet;\n","import baseSet from './_baseSet.js';\n\n/**\n * Sets the value at `path` of `object`. If a portion of `path` doesn't exist,\n * it's created. Arrays are created for missing index properties while objects\n * are created for all other missing properties. Use `_.setWith` to customize\n * `path` creation.\n *\n * **Note:** This method mutates `object`.\n *\n * @static\n * @memberOf _\n * @since 3.7.0\n * @category Object\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @returns {Object} Returns `object`.\n * @example\n *\n * var object = { 'a': [{ 'b': { 'c': 3 } }] };\n *\n * _.set(object, 'a[0].b.c', 4);\n * console.log(object.a[0].b.c);\n * // => 4\n *\n * _.set(object, ['x', '0', 'y', 'z'], 5);\n * console.log(object.x[0].y.z);\n * // => 5\n */\nfunction set(object, path, value) {\n return object == null ? object : baseSet(object, path, value);\n}\n\nexport default set;\n","import assignValue from './_assignValue.js';\nimport castPath from './_castPath.js';\nimport isIndex from './_isIndex.js';\nimport isObject from './isObject.js';\nimport toKey from './_toKey.js';\n\n/**\n * The base implementation of `_.set`.\n *\n * @private\n * @param {Object} object The object to modify.\n * @param {Array|string} path The path of the property to set.\n * @param {*} value The value to set.\n * @param {Function} [customizer] The function to customize path creation.\n * @returns {Object} Returns `object`.\n */\nfunction baseSet(object, path, value, customizer) {\n if (!isObject(object)) {\n return object;\n }\n path = castPath(path, object);\n\n var index = -1,\n length = path.length,\n lastIndex = length - 1,\n nested = object;\n\n while (nested != null && ++index < length) {\n var key = toKey(path[index]),\n newValue = value;\n\n if (key === '__proto__' || key === 'constructor' || key === 'prototype') {\n return object;\n }\n\n if (index != lastIndex) {\n var objValue = nested[key];\n newValue = customizer ? customizer(objValue, key, nested) : undefined;\n if (newValue === undefined) {\n newValue = isObject(objValue)\n ? objValue\n : (isIndex(path[index + 1]) ? [] : {});\n }\n }\n assignValue(nested, key, newValue);\n nested = nested[key];\n }\n return object;\n}\n\nexport default baseSet;\n","import castArray from 'lodash-es/castArray';\nimport isFunction from 'lodash-es/isFunction';\nimport isString from 'lodash-es/isString';\nimport type { SubDomainOptions } from './Options';\n\nexport default {\n range: (value: number): number => Math.max(+value, 1),\n 'date.highlight': (args: Date[] | Date): Date[] => castArray(args),\n 'subDomain.label': (\n value: SubDomainOptions['label'],\n ): string | Function | null =>\n // eslint-disable-next-line\n ((isString(value) && value !== '') || isFunction(value) ? value : null),\n};\n","'use strict';\n/* eslint-disable regexp/no-empty-capturing-group, regexp/no-empty-group, regexp/no-lazy-ends -- testing */\n/* eslint-disable regexp/no-useless-quantifier -- testing */\nvar call = require('../internals/function-call');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toString = require('../internals/to-string');\nvar regexpFlags = require('../internals/regexp-flags');\nvar stickyHelpers = require('../internals/regexp-sticky-helpers');\nvar shared = require('../internals/shared');\nvar create = require('../internals/object-create');\nvar getInternalState = require('../internals/internal-state').get;\nvar UNSUPPORTED_DOT_ALL = require('../internals/regexp-unsupported-dot-all');\nvar UNSUPPORTED_NCG = require('../internals/regexp-unsupported-ncg');\n\nvar nativeReplace = shared('native-string-replace', String.prototype.replace);\nvar nativeExec = RegExp.prototype.exec;\nvar patchedExec = nativeExec;\nvar charAt = uncurryThis(''.charAt);\nvar indexOf = uncurryThis(''.indexOf);\nvar replace = uncurryThis(''.replace);\nvar stringSlice = uncurryThis(''.slice);\n\nvar UPDATES_LAST_INDEX_WRONG = (function () {\n var re1 = /a/;\n var re2 = /b*/g;\n call(nativeExec, re1, 'a');\n call(nativeExec, re2, 'a');\n return re1.lastIndex !== 0 || re2.lastIndex !== 0;\n})();\n\nvar UNSUPPORTED_Y = stickyHelpers.BROKEN_CARET;\n\n// nonparticipating capturing group, copied from es5-shim's String#split patch.\nvar NPCG_INCLUDED = /()??/.exec('')[1] !== undefined;\n\nvar PATCH = UPDATES_LAST_INDEX_WRONG || NPCG_INCLUDED || UNSUPPORTED_Y || UNSUPPORTED_DOT_ALL || UNSUPPORTED_NCG;\n\nif (PATCH) {\n patchedExec = function exec(string) {\n var re = this;\n var state = getInternalState(re);\n var str = toString(string);\n var raw = state.raw;\n var result, reCopy, lastIndex, match, i, object, group;\n\n if (raw) {\n raw.lastIndex = re.lastIndex;\n result = call(patchedExec, raw, str);\n re.lastIndex = raw.lastIndex;\n return result;\n }\n\n var groups = state.groups;\n var sticky = UNSUPPORTED_Y && re.sticky;\n var flags = call(regexpFlags, re);\n var source = re.source;\n var charsAdded = 0;\n var strCopy = str;\n\n if (sticky) {\n flags = replace(flags, 'y', '');\n if (indexOf(flags, 'g') === -1) {\n flags += 'g';\n }\n\n strCopy = stringSlice(str, re.lastIndex);\n // Support anchored sticky behavior.\n if (re.lastIndex > 0 && (!re.multiline || re.multiline && charAt(str, re.lastIndex - 1) !== '\\n')) {\n source = '(?: ' + source + ')';\n strCopy = ' ' + strCopy;\n charsAdded++;\n }\n // ^(? + rx + ) is needed, in combination with some str slicing, to\n // simulate the 'y' flag.\n reCopy = new RegExp('^(?:' + source + ')', flags);\n }\n\n if (NPCG_INCLUDED) {\n reCopy = new RegExp('^' + source + '$(?!\\\\s)', flags);\n }\n if (UPDATES_LAST_INDEX_WRONG) lastIndex = re.lastIndex;\n\n match = call(nativeExec, sticky ? reCopy : re, strCopy);\n\n if (sticky) {\n if (match) {\n match.input = stringSlice(match.input, charsAdded);\n match[0] = stringSlice(match[0], charsAdded);\n match.index = re.lastIndex;\n re.lastIndex += match[0].length;\n } else re.lastIndex = 0;\n } else if (UPDATES_LAST_INDEX_WRONG && match) {\n re.lastIndex = re.global ? match.index + match[0].length : lastIndex;\n }\n if (NPCG_INCLUDED && match && match.length > 1) {\n // Fix browsers whose `exec` methods don't consistently return `undefined`\n // for NPCG, like IE8. NOTE: This doesn't work for /(.?)?/\n call(nativeReplace, match[0], reCopy, function () {\n for (i = 1; i < arguments.length - 2; i++) {\n if (arguments[i] === undefined) match[i] = undefined;\n }\n });\n }\n\n if (match && groups) {\n match.groups = object = create(null);\n for (i = 0; i < groups.length; i++) {\n group = groups[i];\n object[group[0]] = match[group[1]];\n }\n }\n\n return match;\n };\n}\n\nmodule.exports = patchedExec;\n","import baseGetTag from './_baseGetTag.js';\nimport isArray from './isArray.js';\nimport isObjectLike from './isObjectLike.js';\n\n/** `Object#toString` result references. */\nvar stringTag = '[object String]';\n\n/**\n * Checks if `value` is classified as a `String` primitive or object.\n *\n * @static\n * @since 0.1.0\n * @memberOf _\n * @category Lang\n * @param {*} value The value to check.\n * @returns {boolean} Returns `true` if `value` is a string, else `false`.\n * @example\n *\n * _.isString('abc');\n * // => true\n *\n * _.isString(1);\n * // => false\n */\nfunction isString(value) {\n return typeof value == 'string' ||\n (!isArray(value) && isObjectLike(value) && baseGetTag(value) == stringTag);\n}\n\nexport default isString;\n","import mergeWith from 'lodash-es/mergeWith';\nimport isEqual from 'lodash-es/isEqual';\nimport has from 'lodash-es/has';\nimport get from 'lodash-es/get';\nimport set from 'lodash-es/set';\nimport type { Ls } from 'dayjs';\nimport type { DomainType, Timestamp } from '../index';\nimport {\n OPTIONS_DEFAULT_DOMAIN_TYPE,\n OPTIONS_DEFAULT_SUBDOMAIN_TYPE,\n OPTIONS_DEFAULT_SUBDOMAIN_WIDTH,\n OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT,\n OPTIONS_DEFAULT_SUBDOMAIN_GUTTER,\n OPTIONS_DEFAULT_SUBDOMAIN_RADIUS,\n OPTIONS_DEFAULT_THEME,\n OPTIONS_DEFAULT_ANIMATION_DURATION,\n OPTIONS_DEFAULT_ITEM_SELECTOR,\n OPTIONS_DEFAULT_RANGE,\n SCALE_BASE_COLOR_SCHEME,\n SCALE_BASE_COLOR_TYPE,\n SCALE_BASE_COLOR_DOMAIN,\n OPTIONS_DEFAULT_LOCALE,\n} from '../constant';\n\nimport OptionsPreProcessors from './OptionsPreProcessors';\n\ntype SortOrder = 'asc' | 'desc';\nexport type TextAlign = 'start' | 'middle' | 'end';\nexport type Padding = [number, number, number, number];\n\nexport type DomainOptions = {\n type: DomainType;\n gutter: number;\n padding: Padding;\n dynamicDimension: boolean;\n label: LabelOptions;\n sort: SortOrder;\n};\n\ntype LabelOptions = {\n text?:\n | string\n | null\n | ((timestamp: Timestamp, element: SVGElement) => string);\n position: 'top' | 'right' | 'bottom' | 'left';\n textAlign: TextAlign;\n offset: {\n x: number;\n y: number;\n };\n rotate: null | 'left' | 'right';\n width: number;\n height: number;\n};\n\nexport type SubDomainOptions = {\n type: string;\n width: number;\n height: number;\n gutter: number;\n radius: number;\n label:\n | string\n | null\n | ((timestamp: Timestamp, value: number, element: SVGElement) => string);\n color?:\n | string\n | ((\n timestamp: Timestamp,\n value: number | string | null | undefined,\n backgroundColor: string,\n ) => string);\n sort: SortOrder;\n};\n\nexport type DataGroupType = 'sum' | 'count' | 'min' | 'max' | 'average';\n\ntype DateOptions = {\n start: Date;\n min?: Date;\n max?: Date;\n highlight: Date[];\n locale: string | Partial<(typeof Ls)[0]>;\n timezone?: string;\n};\n\nexport type DataRecord = Record;\nexport type DataOptions = {\n source: string | DataRecord[];\n type: 'json' | 'csv' | 'tsv' | 'txt';\n requestInit: object;\n x: string | ((datum: DataRecord) => number);\n y: string | ((datum: DataRecord) => number);\n groupY:\n | DataGroupType\n | ((values: (string | number | null)[]) => string | number | null);\n defaultValue: null | number | string;\n};\n\ntype ScaleOptions = {\n opacity?: {\n domain: number[];\n type?: string;\n baseColor: string;\n };\n color?: {\n domain: number[];\n scheme?: string;\n range?: string[];\n interpolate?: any;\n type?: string;\n };\n};\n\nexport type OptionsType = {\n itemSelector: string;\n range: number;\n domain: DomainOptions;\n subDomain: SubDomainOptions;\n date: DateOptions;\n data: DataOptions;\n scale?: ScaleOptions;\n animationDuration: number;\n verticalOrientation: boolean;\n theme: 'light' | 'dark';\n};\n\ntype InternalOptionsType = {\n x: {\n domainHorizontalLabelWidth: number;\n domainVerticalLabelHeight: number;\n };\n};\n\nexport default class Options {\n options: OptionsType & InternalOptionsType;\n\n preProcessors: {\n [key: string]: (value: any) => any;\n };\n\n constructor(processors = OptionsPreProcessors) {\n this.preProcessors = processors;\n\n this.options = {\n // selector string of the container to append the graph to\n // Accept any string value accepted by document.querySelector or CSS3\n // or an Element object\n itemSelector: OPTIONS_DEFAULT_ITEM_SELECTOR,\n\n // Number of domain to display on the graph\n range: OPTIONS_DEFAULT_RANGE,\n\n domain: {\n type: OPTIONS_DEFAULT_DOMAIN_TYPE,\n\n // Space between each domain, in pixel\n gutter: 4,\n\n padding: [0, 0, 0, 0],\n\n // Whether to enable dynamic domain size\n // The width/height on a domain depends on the number of\n // subDomains items count\n dynamicDimension: true,\n\n // Whether to show most recent date first\n sort: 'asc',\n\n label: {\n // Formatting of the domain label\n // @default: undefined, will use the formatting\n // according to domain type\n // Accept any string accepted by dayjs.format()\n // or a function\n //\n // Refer to https://day.js.org/docs/en/display/format\n // for list of accepted string tokens used by dayjs.format()\n text: undefined,\n\n // valid: top, right, bottom, left\n position: 'bottom',\n\n // Valid are the direct svg values: start, middle, end\n textAlign: 'middle',\n\n // By default, there is no margin/padding around the label\n offset: {\n x: 0,\n y: 0,\n },\n\n rotate: null,\n\n // Used only on vertical orientation\n width: 100,\n\n // Used only on horizontal orientation\n height: 25,\n },\n },\n\n subDomain: {\n type: OPTIONS_DEFAULT_SUBDOMAIN_TYPE,\n\n // Width of each subDomain cell, in pixel\n width: OPTIONS_DEFAULT_SUBDOMAIN_WIDTH,\n\n // Height of each subDomain cell, in pixel\n height: OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT,\n\n // Space between each subDomain cell, in pixel\n gutter: OPTIONS_DEFAULT_SUBDOMAIN_GUTTER,\n\n // Radius of each subDomain cell, in pixel\n radius: OPTIONS_DEFAULT_SUBDOMAIN_RADIUS,\n\n // Formatting of the text inside each subDomain cell\n // @default: null, no text\n // Accept any string accepted by dayjs.format()\n // or a function\n //\n // Refer to https://day.js.org/docs/en/display/format\n // for list of accepted string tokens used by dayjs.format()\n label: null,\n\n color: undefined,\n\n sort: 'asc',\n },\n\n date: {\n // Start date of the graph\n // @default now\n start: new Date(),\n\n min: undefined,\n\n max: undefined,\n\n // List of dates to highlight\n // Valid values:\n // - []: don't highlight anything\n // - an array of Date objects: highlight the specified dates\n highlight: [],\n\n locale: OPTIONS_DEFAULT_LOCALE,\n\n timezone: undefined,\n },\n\n // Calendar orientation\n // false: display domains side by side\n // true : display domains one under the other\n verticalOrientation: false,\n\n data: {\n // Data source\n // URL, where to fetch the original datas\n source: '',\n\n // Data type\n // Default: json\n type: 'json',\n\n requestInit: {},\n\n // keyname of the time property\n x: '',\n\n // keyname of the value property\n y: '',\n\n // Grouping function of the values\n groupY: 'sum',\n\n defaultValue: null,\n },\n\n scale: undefined,\n\n // Animation duration, in ms\n animationDuration: OPTIONS_DEFAULT_ANIMATION_DURATION,\n\n // Theme mode: dark/light\n theme: OPTIONS_DEFAULT_THEME,\n\n // Internally used options, do not edit not set\n x: {\n domainHorizontalLabelWidth: 0,\n domainVerticalLabelHeight: 0,\n },\n };\n }\n\n /**\n * Set a new value for an option, only if unchanged\n * @param {string} key Name of the option\n * @param {any} value Value of the option\n * @return {boolean} Whether the option have been changed\n */\n set(key: string, value: any): boolean {\n if (!has(this.options, key) || isEqual(get(this.options, key), value)) {\n return false;\n }\n\n set(\n this.options,\n key,\n has(this.preProcessors, key) ?\n get(this.preProcessors, key)(value) :\n value,\n );\n\n return true;\n }\n\n init(opts?: CalHeatmap.DeepPartial): void {\n this.options = {\n // eslint-disable-next-line arrow-body-style\n ...mergeWith(this.options, opts, (_, srcValue) => {\n return Array.isArray(srcValue) ? srcValue : undefined;\n }),\n };\n\n const { options } = this;\n\n Object.keys(this.preProcessors).forEach((key) => {\n set(options, key, get(this.preProcessors, key)(get(options, key)));\n });\n\n if (typeof options.scale === 'undefined') {\n this.initScale();\n }\n\n options.x.domainVerticalLabelHeight = options.domain.label.height;\n\n // When the label is affecting the height\n if (\n options.domain.label.position === 'top' ||\n options.domain.label.position === 'bottom'\n ) {\n options.x.domainHorizontalLabelWidth = 0;\n } else {\n options.x.domainVerticalLabelHeight = 0;\n options.x.domainHorizontalLabelWidth = options.domain.label.width;\n }\n\n if (\n options.domain.label.text === null ||\n options.domain.label.text === ''\n ) {\n options.x.domainVerticalLabelHeight = 0;\n options.x.domainHorizontalLabelWidth = 0;\n }\n }\n\n initScale() {\n this.options.scale = {\n color: {\n scheme: SCALE_BASE_COLOR_SCHEME,\n type: SCALE_BASE_COLOR_TYPE,\n domain: SCALE_BASE_COLOR_DOMAIN,\n },\n };\n }\n}\n","'use strict';\nvar anObject = require('../internals/an-object');\n\n// `RegExp.prototype.flags` getter implementation\n// https://tc39.es/ecma262/#sec-get-regexp.prototype.flags\nmodule.exports = function () {\n var that = anObject(this);\n var result = '';\n if (that.hasIndices) result += 'd';\n if (that.global) result += 'g';\n if (that.ignoreCase) result += 'i';\n if (that.multiline) result += 'm';\n if (that.dotAll) result += 's';\n if (that.unicode) result += 'u';\n if (that.unicodeSets) result += 'v';\n if (that.sticky) result += 'y';\n return result;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\n// babel-minify and Closure Compiler transpiles RegExp('a', 'y') -> /a/y and it causes SyntaxError\nvar $RegExp = global.RegExp;\n\nvar UNSUPPORTED_Y = fails(function () {\n var re = $RegExp('a', 'y');\n re.lastIndex = 2;\n return re.exec('abcd') !== null;\n});\n\n// UC Browser bug\n// https://github.com/zloirock/core-js/issues/1008\nvar MISSED_STICKY = UNSUPPORTED_Y || fails(function () {\n return !$RegExp('a', 'y').sticky;\n});\n\nvar BROKEN_CARET = UNSUPPORTED_Y || fails(function () {\n // https://bugzilla.mozilla.org/show_bug.cgi?id=773687\n var re = $RegExp('^r', 'gy');\n re.lastIndex = 2;\n return re.exec('str') !== null;\n});\n\nmodule.exports = {\n BROKEN_CARET: BROKEN_CARET,\n MISSED_STICKY: MISSED_STICKY,\n UNSUPPORTED_Y: UNSUPPORTED_Y\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\n// babel-minify and Closure Compiler transpiles RegExp('.', 's') -> /./s and it causes SyntaxError\nvar $RegExp = global.RegExp;\n\nmodule.exports = fails(function () {\n var re = $RegExp('.', 's');\n return !(re.dotAll && re.test('\\n') && re.flags === 's');\n});\n","'use strict';\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\n// babel-minify and Closure Compiler transpiles RegExp('(?b)', 'g') -> /(?b)/g and it causes SyntaxError\nvar $RegExp = global.RegExp;\n\nmodule.exports = fails(function () {\n var re = $RegExp('(?b)', 'g');\n return re.exec('b').groups.a !== 'b' ||\n 'b'.replace(re, '$c') !== 'bc';\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar exec = require('../internals/regexp-exec');\n\n// `RegExp.prototype.exec` method\n// https://tc39.es/ecma262/#sec-regexp.prototype.exec\n$({ target: 'RegExp', proto: true, forced: /./.exec !== exec }, {\n exec: exec\n});\n","'use strict';\n// TODO: Remove from `core-js@4` since it's moved to entry points\nrequire('../modules/es.regexp.exec');\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar regexpExec = require('../internals/regexp-exec');\nvar fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar SPECIES = wellKnownSymbol('species');\nvar RegExpPrototype = RegExp.prototype;\n\nmodule.exports = function (KEY, exec, FORCED, SHAM) {\n var SYMBOL = wellKnownSymbol(KEY);\n\n var DELEGATES_TO_SYMBOL = !fails(function () {\n // String methods call symbol-named RegEp methods\n var O = {};\n O[SYMBOL] = function () { return 7; };\n return ''[KEY](O) !== 7;\n });\n\n var DELEGATES_TO_EXEC = DELEGATES_TO_SYMBOL && !fails(function () {\n // Symbol-named RegExp methods call .exec\n var execCalled = false;\n var re = /a/;\n\n if (KEY === 'split') {\n // We can't use real regex here since it causes deoptimization\n // and serious performance degradation in V8\n // https://github.com/zloirock/core-js/issues/306\n re = {};\n // RegExp[@@split] doesn't call the regex's exec method, but first creates\n // a new one. We need to return the patched regex when creating the new one.\n re.constructor = {};\n re.constructor[SPECIES] = function () { return re; };\n re.flags = '';\n re[SYMBOL] = /./[SYMBOL];\n }\n\n re.exec = function () {\n execCalled = true;\n return null;\n };\n\n re[SYMBOL]('');\n return !execCalled;\n });\n\n if (\n !DELEGATES_TO_SYMBOL ||\n !DELEGATES_TO_EXEC ||\n FORCED\n ) {\n var uncurriedNativeRegExpMethod = uncurryThis(/./[SYMBOL]);\n var methods = exec(SYMBOL, ''[KEY], function (nativeMethod, regexp, str, arg2, forceStringMethod) {\n var uncurriedNativeMethod = uncurryThis(nativeMethod);\n var $exec = regexp.exec;\n if ($exec === regexpExec || $exec === RegExpPrototype.exec) {\n if (DELEGATES_TO_SYMBOL && !forceStringMethod) {\n // The native String method already delegates to @@method (this\n // polyfilled function), leasing to infinite recursion.\n // We avoid it by directly calling the native @@method method.\n return { done: true, value: uncurriedNativeRegExpMethod(regexp, str, arg2) };\n }\n return { done: true, value: uncurriedNativeMethod(str, regexp, arg2) };\n }\n return { done: false };\n });\n\n defineBuiltIn(String.prototype, KEY, methods[0]);\n defineBuiltIn(RegExpPrototype, SYMBOL, methods[1]);\n }\n\n if (SHAM) createNonEnumerableProperty(RegExpPrototype[SYMBOL], 'sham', true);\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\n\n// `AdvanceStringIndex` abstract operation\n// https://tc39.es/ecma262/#sec-advancestringindex\nmodule.exports = function (S, index, unicode) {\n return index + (unicode ? charAt(S, index).length : 1);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar floor = Math.floor;\nvar charAt = uncurryThis(''.charAt);\nvar replace = uncurryThis(''.replace);\nvar stringSlice = uncurryThis(''.slice);\n// eslint-disable-next-line redos/no-vulnerable -- safe\nvar SUBSTITUTION_SYMBOLS = /\\$([$&'`]|\\d{1,2}|<[^>]*>)/g;\nvar SUBSTITUTION_SYMBOLS_NO_NAMED = /\\$([$&'`]|\\d{1,2})/g;\n\n// `GetSubstitution` abstract operation\n// https://tc39.es/ecma262/#sec-getsubstitution\nmodule.exports = function (matched, str, position, captures, namedCaptures, replacement) {\n var tailPos = position + matched.length;\n var m = captures.length;\n var symbols = SUBSTITUTION_SYMBOLS_NO_NAMED;\n if (namedCaptures !== undefined) {\n namedCaptures = toObject(namedCaptures);\n symbols = SUBSTITUTION_SYMBOLS;\n }\n return replace(replacement, symbols, function (match, ch) {\n var capture;\n switch (charAt(ch, 0)) {\n case '$': return '$';\n case '&': return matched;\n case '`': return stringSlice(str, 0, position);\n case \"'\": return stringSlice(str, tailPos);\n case '<':\n capture = namedCaptures[stringSlice(ch, 1, -1)];\n break;\n default: // \\d\\d?\n var n = +ch;\n if (n === 0) return match;\n if (n > m) {\n var f = floor(n / 10);\n if (f === 0) return match;\n if (f <= m) return captures[f - 1] === undefined ? charAt(ch, 1) : captures[f - 1] + charAt(ch, 1);\n return match;\n }\n capture = captures[n - 1];\n }\n return capture === undefined ? '' : capture;\n });\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof-raw');\nvar regexpExec = require('../internals/regexp-exec');\n\nvar $TypeError = TypeError;\n\n// `RegExpExec` abstract operation\n// https://tc39.es/ecma262/#sec-regexpexec\nmodule.exports = function (R, S) {\n var exec = R.exec;\n if (isCallable(exec)) {\n var result = call(exec, R, S);\n if (result !== null) anObject(result);\n return result;\n }\n if (classof(R) === 'RegExp') return call(regexpExec, R, S);\n throw new $TypeError('RegExp#exec called on incompatible receiver');\n};\n","'use strict';\nvar apply = require('../internals/function-apply');\nvar call = require('../internals/function-call');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fixRegExpWellKnownSymbolLogic = require('../internals/fix-regexp-well-known-symbol-logic');\nvar fails = require('../internals/fails');\nvar anObject = require('../internals/an-object');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toLength = require('../internals/to-length');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar advanceStringIndex = require('../internals/advance-string-index');\nvar getMethod = require('../internals/get-method');\nvar getSubstitution = require('../internals/get-substitution');\nvar regExpExec = require('../internals/regexp-exec-abstract');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar REPLACE = wellKnownSymbol('replace');\nvar max = Math.max;\nvar min = Math.min;\nvar concat = uncurryThis([].concat);\nvar push = uncurryThis([].push);\nvar stringIndexOf = uncurryThis(''.indexOf);\nvar stringSlice = uncurryThis(''.slice);\n\nvar maybeToString = function (it) {\n return it === undefined ? it : String(it);\n};\n\n// IE <= 11 replaces $0 with the whole match, as if it was $&\n// https://stackoverflow.com/questions/6024666/getting-ie-to-replace-a-regex-with-the-literal-string-0\nvar REPLACE_KEEPS_$0 = (function () {\n // eslint-disable-next-line regexp/prefer-escape-replacement-dollar-char -- required for testing\n return 'a'.replace(/./, '$0') === '$0';\n})();\n\n// Safari <= 13.0.3(?) substitutes nth capture where n>m with an empty string\nvar REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE = (function () {\n if (/./[REPLACE]) {\n return /./[REPLACE]('a', '$0') === '';\n }\n return false;\n})();\n\nvar REPLACE_SUPPORTS_NAMED_GROUPS = !fails(function () {\n var re = /./;\n re.exec = function () {\n var result = [];\n result.groups = { a: '7' };\n return result;\n };\n // eslint-disable-next-line regexp/no-useless-dollar-replacements -- false positive\n return ''.replace(re, '$') !== '7';\n});\n\n// @@replace logic\nfixRegExpWellKnownSymbolLogic('replace', function (_, nativeReplace, maybeCallNative) {\n var UNSAFE_SUBSTITUTE = REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE ? '$' : '$0';\n\n return [\n // `String.prototype.replace` method\n // https://tc39.es/ecma262/#sec-string.prototype.replace\n function replace(searchValue, replaceValue) {\n var O = requireObjectCoercible(this);\n var replacer = isNullOrUndefined(searchValue) ? undefined : getMethod(searchValue, REPLACE);\n return replacer\n ? call(replacer, searchValue, O, replaceValue)\n : call(nativeReplace, toString(O), searchValue, replaceValue);\n },\n // `RegExp.prototype[@@replace]` method\n // https://tc39.es/ecma262/#sec-regexp.prototype-@@replace\n function (string, replaceValue) {\n var rx = anObject(this);\n var S = toString(string);\n\n if (\n typeof replaceValue == 'string' &&\n stringIndexOf(replaceValue, UNSAFE_SUBSTITUTE) === -1 &&\n stringIndexOf(replaceValue, '$<') === -1\n ) {\n var res = maybeCallNative(nativeReplace, rx, S, replaceValue);\n if (res.done) return res.value;\n }\n\n var functionalReplace = isCallable(replaceValue);\n if (!functionalReplace) replaceValue = toString(replaceValue);\n\n var global = rx.global;\n var fullUnicode;\n if (global) {\n fullUnicode = rx.unicode;\n rx.lastIndex = 0;\n }\n\n var results = [];\n var result;\n while (true) {\n result = regExpExec(rx, S);\n if (result === null) break;\n\n push(results, result);\n if (!global) break;\n\n var matchStr = toString(result[0]);\n if (matchStr === '') rx.lastIndex = advanceStringIndex(S, toLength(rx.lastIndex), fullUnicode);\n }\n\n var accumulatedResult = '';\n var nextSourcePosition = 0;\n for (var i = 0; i < results.length; i++) {\n result = results[i];\n\n var matched = toString(result[0]);\n var position = max(min(toIntegerOrInfinity(result.index), S.length), 0);\n var captures = [];\n var replacement;\n // NOTE: This is equivalent to\n // captures = result.slice(1).map(maybeToString)\n // but for some reason `nativeSlice.call(result, 1, result.length)` (called in\n // the slice polyfill when slicing native arrays) \"doesn't work\" in safari 9 and\n // causes a crash (https://pastebin.com/N21QzeQA) when trying to debug it.\n for (var j = 1; j < result.length; j++) push(captures, maybeToString(result[j]));\n var namedCaptures = result.groups;\n if (functionalReplace) {\n var replacerArgs = concat([matched], captures, position, S);\n if (namedCaptures !== undefined) push(replacerArgs, namedCaptures);\n replacement = toString(apply(replaceValue, undefined, replacerArgs));\n } else {\n replacement = getSubstitution(matched, S, position, captures, namedCaptures, replaceValue);\n }\n if (position >= nextSourcePosition) {\n accumulatedResult += stringSlice(S, nextSourcePosition, position) + replacement;\n nextSourcePosition = position + matched.length;\n }\n }\n\n return accumulatedResult + stringSlice(S, nextSourcePosition);\n }\n ];\n}, !REPLACE_SUPPORTS_NAMED_GROUPS || !REPLACE_KEEPS_$0 || REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE);\n","import {\n json, csv, dsv, text,\n} from 'd3-fetch';\n\nimport type { DataOptions, DataRecord } from './options/Options';\nimport type { Timestamp } from './index';\nimport type CalHeatmap from './CalHeatmap';\n\nexport default class DataFetcher {\n calendar: CalHeatmap;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n }\n\n /**\n * Fetch and interpret data from the datasource\n *\n * @param {string|object} source\n * @param {number} startTimestamp\n * @param {number} endTimestamp\n *\n * @return {Promize} A promise, that will return the final data when resolved\n */\n async getDatas(\n source: DataOptions['source'],\n startTimestamp: Timestamp,\n endTimestamp: Timestamp,\n ): Promise {\n if (typeof source === 'string' && source.length > 0) {\n return this.#fetch(source, startTimestamp, endTimestamp);\n }\n\n let d: DataRecord[] = [];\n if (Array.isArray(source)) {\n d = source;\n }\n\n return new Promise((resolve) => {\n resolve(d);\n });\n }\n\n parseURI(\n str: string,\n startTimestamp: Timestamp,\n endTimestamp: Timestamp,\n ): string {\n let newUri = str.replace(/\\{\\{start=(.*?)\\}\\}/g, (_, format) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.calendar.dateHelper.date(startTimestamp).format(format));\n newUri = newUri.replace(/\\{\\{end=(.*?)\\}\\}/g, (_, format) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.calendar.dateHelper.date(endTimestamp).format(format));\n\n return newUri;\n }\n\n #fetch(\n source: DataOptions['source'],\n startTimestamp: Timestamp,\n endTimestamp: Timestamp,\n ): Promise {\n const { type, requestInit } = this.calendar.options.options.data;\n\n const url = this.parseURI(source as string, startTimestamp, endTimestamp);\n\n switch (type) {\n case 'json':\n return json(url, requestInit);\n case 'csv':\n return csv(url, requestInit);\n case 'tsv':\n return dsv('\\t', url, requestInit);\n case 'txt':\n return text(url, requestInit);\n default:\n return new Promise((resolve) => {\n resolve([]);\n });\n }\n }\n}\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar FUNCTION_NAME_EXISTS = require('../internals/function-name').EXISTS;\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\n\nvar FunctionPrototype = Function.prototype;\nvar functionToString = uncurryThis(FunctionPrototype.toString);\nvar nameRE = /function\\b(?:\\s|\\/\\*[\\S\\s]*?\\*\\/|\\/\\/[^\\n\\r]*[\\n\\r]+)*([^\\s(/]*)/;\nvar regExpExec = uncurryThis(nameRE.exec);\nvar NAME = 'name';\n\n// Function instances `.name` property\n// https://tc39.es/ecma262/#sec-function-instances-name\nif (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {\n defineBuiltInAccessor(FunctionPrototype, NAME, {\n configurable: true,\n get: function () {\n try {\n return regExpExec(nameRE, functionToString(this))[1];\n } catch (error) {\n return '';\n }\n }\n });\n}\n","!function(t,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(t=\"undefined\"!=typeof globalThis?globalThis:t||self).dayjs=e()}(this,(function(){\"use strict\";var t=1e3,e=6e4,n=36e5,r=\"millisecond\",i=\"second\",s=\"minute\",u=\"hour\",a=\"day\",o=\"week\",c=\"month\",f=\"quarter\",h=\"year\",d=\"date\",l=\"Invalid Date\",$=/^(\\d{4})[-/]?(\\d{1,2})?[-/]?(\\d{0,2})[Tt\\s]*(\\d{1,2})?:?(\\d{1,2})?:?(\\d{1,2})?[.:]?(\\d+)?$/,y=/\\[([^\\]]+)]|Y{1,4}|M{1,4}|D{1,2}|d{1,4}|H{1,2}|h{1,2}|a|A|m{1,2}|s{1,2}|Z{1,2}|SSS/g,M={name:\"en\",weekdays:\"Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday\".split(\"_\"),months:\"January_February_March_April_May_June_July_August_September_October_November_December\".split(\"_\"),ordinal:function(t){var e=[\"th\",\"st\",\"nd\",\"rd\"],n=t%100;return\"[\"+t+(e[(n-20)%10]||e[n]||e[0])+\"]\"}},m=function(t,e,n){var r=String(t);return!r||r.length>=e?t:\"\"+Array(e+1-r.length).join(n)+t},v={s:m,z:function(t){var e=-t.utcOffset(),n=Math.abs(e),r=Math.floor(n/60),i=n%60;return(e<=0?\"+\":\"-\")+m(r,2,\"0\")+\":\"+m(i,2,\"0\")},m:function t(e,n){if(e.date()1)return t(u[0])}else{var a=e.name;D[a]=e,i=a}return!r&&i&&(g=i),i||!r&&g},O=function(t,e){if(S(t))return t.clone();var n=\"object\"==typeof e?e:{};return n.date=t,n.args=arguments,new _(n)},b=v;b.l=w,b.i=S,b.w=function(t,e){return O(t,{locale:e.$L,utc:e.$u,x:e.$x,$offset:e.$offset})};var _=function(){function M(t){this.$L=w(t.locale,null,!0),this.parse(t),this.$x=this.$x||t.x||{},this[p]=!0}var m=M.prototype;return m.parse=function(t){this.$d=function(t){var e=t.date,n=t.utc;if(null===e)return new Date(NaN);if(b.u(e))return new Date;if(e instanceof Date)return new Date(e);if(\"string\"==typeof e&&!/Z$/i.test(e)){var r=e.match($);if(r){var i=r[2]-1||0,s=(r[7]||\"0\").substring(0,3);return n?new Date(Date.UTC(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)):new Date(r[1],i,r[3]||1,r[4]||0,r[5]||0,r[6]||0,s)}}return new Date(e)}(t),this.init()},m.init=function(){var t=this.$d;this.$y=t.getFullYear(),this.$M=t.getMonth(),this.$D=t.getDate(),this.$W=t.getDay(),this.$H=t.getHours(),this.$m=t.getMinutes(),this.$s=t.getSeconds(),this.$ms=t.getMilliseconds()},m.$utils=function(){return b},m.isValid=function(){return!(this.$d.toString()===l)},m.isSame=function(t,e){var n=O(t);return this.startOf(e)<=n&&n<=this.endOf(e)},m.isAfter=function(t,e){return O(t)25){var f=r(this).startOf(t).add(1,t).date(n),s=r(this).endOf(e);if(f.isBefore(s))return 1}var a=r(this).startOf(t).date(n).startOf(e).subtract(1,\"millisecond\"),o=this.diff(a,e,!0);return o<0?r(this).startOf(\"week\").week():Math.ceil(o)},f.weeks=function(e){return void 0===e&&(e=null),this.week(e)}}}));","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_dayOfYear=t()}(this,(function(){\"use strict\";return function(e,t,n){t.prototype.dayOfYear=function(e){var t=Math.round((n(this).startOf(\"day\")-n(this).startOf(\"year\"))/864e5)+1;return null==e?t:this.add(e-t,\"day\")}}}));","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_weekday=t()}(this,(function(){\"use strict\";return function(e,t){t.prototype.weekday=function(e){var t=this.$locale().weekStart||0,i=this.$W,n=(i0&&(n=n[0]);t=(n=n.filter((function(e){return e})))[0];for(var i=1;i4&&(o+=7),n.add(o,e));return r.diff(u,\"week\")+1},d.isoWeekday=function(e){return this.$utils().u(e)?this.day()||7:this.day(this.day()%7?e:e-7)};var n=d.startOf;d.startOf=function(e,t){var i=this.$utils(),s=!!i.u(t)||t;return\"isoweek\"===i.p(e)?s?this.date(this.date()-(this.isoWeekday()-1)).startOf(\"day\"):this.date(this.date()-1-(this.isoWeekday()-1)+7).endOf(\"day\"):n.bind(this)(e,t)}}}));","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_isLeapYear=t()}(this,(function(){\"use strict\";return function(e,t){t.prototype.isLeapYear=function(){return this.$y%4==0&&this.$y%100!=0||this.$y%400==0}}}));","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_advancedFormat=t()}(this,(function(){\"use strict\";return function(e,t){var r=t.prototype,n=r.format;r.format=function(e){var t=this,r=this.$locale();if(!this.isValid())return n.bind(this)(e);var s=this.$utils(),a=(e||\"YYYY-MM-DDTHH:mm:ssZ\").replace(/\\[([^\\]]+)]|Q|wo|ww|w|WW|W|zzz|z|gggg|GGGG|Do|X|x|k{1,2}|S/g,(function(e){switch(e){case\"Q\":return Math.ceil((t.$M+1)/3);case\"Do\":return r.ordinal(t.$D);case\"gggg\":return t.weekYear();case\"GGGG\":return t.isoWeekYear();case\"wo\":return r.ordinal(t.week(),\"W\");case\"w\":case\"ww\":return s.s(t.week(),\"w\"===e?1:2,\"0\");case\"W\":case\"WW\":return s.s(t.isoWeek(),\"W\"===e?1:2,\"0\");case\"k\":case\"kk\":return s.s(String(0===t.$H?24:t.$H),\"k\"===e?1:2,\"0\");case\"X\":return Math.floor(t.$d.getTime()/1e3);case\"x\":return t.$d.getTime();case\"z\":return\"[\"+t.offsetName()+\"]\";case\"zzz\":return\"[\"+t.offsetName(\"long\")+\"]\";default:return e}}));return n.bind(this)(a)}}}));","!function(t,i){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=i():\"function\"==typeof define&&define.amd?define(i):(t=\"undefined\"!=typeof globalThis?globalThis:t||self).dayjs_plugin_utc=i()}(this,(function(){\"use strict\";var t=\"minute\",i=/[+-]\\d\\d(?::?\\d\\d)?/g,e=/([+-]|\\d\\d)/g;return function(s,f,n){var u=f.prototype;n.utc=function(t){var i={date:t,utc:!0,args:arguments};return new f(i)},u.utc=function(i){var e=n(this.toDate(),{locale:this.$L,utc:!0});return i?e.add(this.utcOffset(),t):e},u.local=function(){return n(this.toDate(),{locale:this.$L,utc:!1})};var o=u.parse;u.parse=function(t){t.utc&&(this.$u=!0),this.$utils().u(t.$offset)||(this.$offset=t.$offset),o.call(this,t)};var r=u.init;u.init=function(){if(this.$u){var t=this.$d;this.$y=t.getUTCFullYear(),this.$M=t.getUTCMonth(),this.$D=t.getUTCDate(),this.$W=t.getUTCDay(),this.$H=t.getUTCHours(),this.$m=t.getUTCMinutes(),this.$s=t.getUTCSeconds(),this.$ms=t.getUTCMilliseconds()}else r.call(this)};var a=u.utcOffset;u.utcOffset=function(s,f){var n=this.$utils().u;if(n(s))return this.$u?0:n(this.$offset)?a.call(this):this.$offset;if(\"string\"==typeof s&&(s=function(t){void 0===t&&(t=\"\");var s=t.match(i);if(!s)return null;var f=(\"\"+s[0]).match(e)||[\"-\",0,0],n=f[0],u=60*+f[1]+ +f[2];return 0===u?0:\"+\"===n?u:-u}(s),null===s))return this;var u=Math.abs(s)<=16?60*s:s,o=this;if(f)return o.$offset=u,o.$u=0===s,o;if(0!==s){var r=this.$u?this.toDate().getTimezoneOffset():-1*this.utcOffset();(o=this.local().add(u+r,t)).$offset=u,o.$x.$localOffset=r}else o=this.utc();return o};var h=u.format;u.format=function(t){var i=t||(this.$u?\"YYYY-MM-DDTHH:mm:ss[Z]\":\"\");return h.call(this,i)},u.valueOf=function(){var t=this.$utils().u(this.$offset)?0:this.$offset+(this.$x.$localOffset||this.$d.getTimezoneOffset());return this.$d.valueOf()-6e4*t},u.isUTC=function(){return!!this.$u},u.toISOString=function(){return this.toDate().toISOString()},u.toString=function(){return this.toDate().toUTCString()};var l=u.toDate;u.toDate=function(t){return\"s\"===t&&this.$offset?n(this.format(\"YYYY-MM-DD HH:mm:ss:SSS\")).toDate():l.call(this)};var c=u.diff;u.diff=function(t,i,e){if(t&&this.$u===t.$u)return c.call(this,t,i,e);var s=this.local(),f=n(t).local();return c.call(s,f,i,e)}}}));","!function(t,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(t=\"undefined\"!=typeof globalThis?globalThis:t||self).dayjs_plugin_timezone=e()}(this,(function(){\"use strict\";var t={year:0,month:1,day:2,hour:3,minute:4,second:5},e={};return function(n,i,o){var r,a=function(t,n,i){void 0===i&&(i={});var o=new Date(t),r=function(t,n){void 0===n&&(n={});var i=n.timeZoneName||\"short\",o=t+\"|\"+i,r=e[o];return r||(r=new Intl.DateTimeFormat(\"en-US\",{hour12:!1,timeZone:t,year:\"numeric\",month:\"2-digit\",day:\"2-digit\",hour:\"2-digit\",minute:\"2-digit\",second:\"2-digit\",timeZoneName:i}),e[o]=r),r}(n,i);return r.formatToParts(o)},u=function(e,n){for(var i=a(e,n),r=[],u=0;u=0&&(r[c]=parseInt(m,10))}var d=r[3],l=24===d?0:d,h=r[0]+\"-\"+r[1]+\"-\"+r[2]+\" \"+l+\":\"+r[4]+\":\"+r[5]+\":000\",v=+e;return(o.utc(h).valueOf()-(v-=v%1e3))/6e4},f=i.prototype;f.tz=function(t,e){void 0===t&&(t=r);var n=this.utcOffset(),i=this.toDate(),a=i.toLocaleString(\"en-US\",{timeZone:t}),u=Math.round((i-new Date(a))/1e3/60),f=o(a,{locale:this.$L}).$set(\"millisecond\",this.$ms).utcOffset(15*-Math.round(i.getTimezoneOffset()/15)-u,!0);if(e){var s=f.utcOffset();f=f.add(n-s,\"minute\")}return f.$x.$timezone=t,f},f.offsetName=function(t){var e=this.$x.$timezone||o.tz.guess(),n=a(this.valueOf(),e,{timeZoneName:t}).find((function(t){return\"timezonename\"===t.type.toLowerCase()}));return n&&n.value};var s=f.startOf;f.startOf=function(t,e){if(!this.$x||!this.$x.$timezone)return s.call(this,t,e);var n=o(this.format(\"YYYY-MM-DD HH:mm:ss:SSS\"),{locale:this.$L});return s.call(n,t,e).tz(this.$x.$timezone,!0)},o.tz=function(t,e,n){var i=n&&e,a=n||e||r,f=u(+o(),a);if(\"string\"!=typeof t)return o(t).tz(a);var s=function(t,e,n){var i=t-60*e*1e3,o=u(i,n);if(e===o)return[i,e];var r=u(i-=60*(o-e)*1e3,n);return o===r?[i,o]:[t-60*Math.min(o,r)*1e3,Math.max(o,r)]}(o.utc(t,i).valueOf(),f,a),m=s[0],c=s[1],d=o(m).utcOffset(c);return d.$x.$timezone=a,d},o.tz.guess=function(){return Intl.DateTimeFormat().resolvedOptions().timeZone},o.tz.setDefault=function(t){r=t}}}));","!function(n,e){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=e():\"function\"==typeof define&&define.amd?define(e):(n=\"undefined\"!=typeof globalThis?globalThis:n||self).dayjs_plugin_localeData=e()}(this,(function(){\"use strict\";return function(n,e,t){var r=e.prototype,o=function(n){return n&&(n.indexOf?n:n.s)},u=function(n,e,t,r,u){var i=n.name?n:n.$locale(),a=o(i[e]),s=o(i[t]),f=a||s.map((function(n){return n.slice(0,r)}));if(!u)return f;var d=i.weekStart;return f.map((function(n,e){return f[(e+(d||0))%7]}))},i=function(){return t.Ls[t.locale()]},a=function(n,e){return n.formats[e]||function(n){return n.replace(/(\\[[^\\]]+])|(MMMM|MM|DD|dddd)/g,(function(n,e,t){return e||t.slice(1)}))}(n.formats[e.toUpperCase()])},s=function(){var n=this;return{months:function(e){return e?e.format(\"MMMM\"):u(n,\"months\")},monthsShort:function(e){return e?e.format(\"MMM\"):u(n,\"monthsShort\",\"months\",3)},firstDayOfWeek:function(){return n.$locale().weekStart||0},weekdays:function(e){return e?e.format(\"dddd\"):u(n,\"weekdays\")},weekdaysMin:function(e){return e?e.format(\"dd\"):u(n,\"weekdaysMin\",\"weekdays\",2)},weekdaysShort:function(e){return e?e.format(\"ddd\"):u(n,\"weekdaysShort\",\"weekdays\",3)},longDateFormat:function(e){return a(n.$locale(),e)},meridiem:this.$locale().meridiem,ordinal:this.$locale().ordinal}};r.localeData=function(){return s.bind(this)()},t.localeData=function(){var n=i();return{firstDayOfWeek:function(){return n.weekStart||0},weekdays:function(){return t.weekdays()},weekdaysShort:function(){return t.weekdaysShort()},weekdaysMin:function(){return t.weekdaysMin()},months:function(){return t.months()},monthsShort:function(){return t.monthsShort()},longDateFormat:function(e){return a(n,e)},meridiem:n.meridiem,ordinal:n.ordinal}},t.months=function(){return u(i(),\"months\")},t.monthsShort=function(){return u(i(),\"monthsShort\",\"months\",3)},t.weekdays=function(n){return u(i(),\"weekdays\",null,null,n)},t.weekdaysShort=function(n){return u(i(),\"weekdaysShort\",\"weekdays\",3,n)},t.weekdaysMin=function(n){return u(i(),\"weekdaysMin\",\"weekdays\",2,n)}}}));","!function(e,t){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=t():\"function\"==typeof define&&define.amd?define(t):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_localizedFormat=t()}(this,(function(){\"use strict\";var e={LTS:\"h:mm:ss A\",LT:\"h:mm A\",L:\"MM/DD/YYYY\",LL:\"MMMM D, YYYY\",LLL:\"MMMM D, YYYY h:mm A\",LLLL:\"dddd, MMMM D, YYYY h:mm A\"};return function(t,o,n){var r=o.prototype,i=r.format;n.en.formats=e,r.format=function(t){void 0===t&&(t=\"YYYY-MM-DDTHH:mm:ssZ\");var o=this.$locale().formats,n=function(t,o){return t.replace(/(\\[[^\\]]+])|(LTS?|l{1,4}|L{1,4})/g,(function(t,n,r){var i=r&&r.toUpperCase();return n||o[r]||e[r]||o[i].replace(/(\\[[^\\]]+])|(MMMM|MM|DD|dddd)/g,(function(e,t,o){return t||o.slice(1)}))}))}(t,void 0===o?{}:o);return i.call(this,n)}}}));","!function(e,n){\"object\"==typeof exports&&\"undefined\"!=typeof module?module.exports=n():\"function\"==typeof define&&define.amd?define(n):(e=\"undefined\"!=typeof globalThis?globalThis:e||self).dayjs_plugin_updateLocale=n()}(this,(function(){\"use strict\";return function(e,n,t){t.updateLocale=function(e,n){var o=t.Ls[e];if(o)return(n?Object.keys(n):[]).forEach((function(e){o[e]=n[e]})),o}}}));","import dayjs from 'dayjs';\nimport weekOfYear from 'dayjs/plugin/weekOfYear';\nimport dayOfYear from 'dayjs/plugin/dayOfYear';\nimport weekday from 'dayjs/plugin/weekday';\nimport minMax from 'dayjs/plugin/minMax';\nimport isoWeeksInYear from 'dayjs/plugin/isoWeeksInYear';\nimport isoWeek from 'dayjs/plugin/isoWeek';\nimport isLeapYear from 'dayjs/plugin/isLeapYear';\nimport advancedFormat from 'dayjs/plugin/advancedFormat';\nimport utc from 'dayjs/plugin/utc';\nimport timezone from 'dayjs/plugin/timezone';\nimport localeData from 'dayjs/plugin/localeData';\nimport localizedFormat from 'dayjs/plugin/localizedFormat';\nimport updateLocale from 'dayjs/plugin/updateLocale';\n\nimport type { ManipulateType, PluginFunc, Ls } from 'dayjs';\nimport type { OptionsType } from '../options/Options';\nimport type { Timestamp, DomainType } from '../index';\n\ndayjs.extend(weekOfYear);\ndayjs.extend(isoWeeksInYear);\ndayjs.extend(isoWeek);\ndayjs.extend(isLeapYear);\ndayjs.extend(dayOfYear);\ndayjs.extend(weekday);\ndayjs.extend(minMax);\ndayjs.extend(advancedFormat);\ndayjs.extend(utc);\ndayjs.extend(timezone);\ndayjs.extend(localeData);\ndayjs.extend(localizedFormat);\ndayjs.extend(updateLocale);\n\nconst DEFAULT_LOCALE = 'en';\n\nexport default class DateHelper {\n locale: OptionsType['date']['locale'];\n\n timezone: string;\n\n constructor() {\n this.locale = DEFAULT_LOCALE;\n this.timezone = dayjs.tz.guess();\n if (typeof window === 'object') {\n (window as any).dayjs ||= dayjs;\n }\n }\n\n async setup({ options }: { options: OptionsType }) {\n this.timezone = options.date.timezone || dayjs.tz.guess();\n const userLocale = options.date.locale;\n\n if (typeof userLocale === 'string' && userLocale !== DEFAULT_LOCALE) {\n let locale;\n if (typeof window === 'object') {\n locale =\n (window as any)[`dayjs_locale_${userLocale}`] ||\n (await this.loadBrowserLocale(userLocale));\n } else {\n locale = await this.loadNodeLocale(userLocale);\n }\n dayjs.locale(userLocale);\n this.locale = locale;\n }\n\n if (typeof userLocale === 'object') {\n if (userLocale.hasOwnProperty('name')) {\n dayjs.locale(userLocale.name, userLocale);\n this.locale = userLocale;\n } else {\n this.locale = dayjs.updateLocale(DEFAULT_LOCALE, userLocale);\n }\n }\n }\n\n // eslint-disable-next-line class-methods-use-this\n extend(dayjsPlugin: PluginFunc): dayjs.Dayjs {\n return dayjs.extend(dayjsPlugin);\n }\n\n /**\n * Return the week number, relative to its month\n *\n * @param {number|Date} d Date or timestamp in milliseconds\n * @returns {number} The week number, relative to the month [0-5]\n */\n getMonthWeekNumber(d: Timestamp | dayjs.Dayjs): number {\n const dayjsDate = this.date(d);\n const date = dayjsDate.startOf('day');\n const endOfWeek = dayjsDate.startOf('month').endOf('week');\n\n if (date <= endOfWeek) {\n return 1;\n }\n return Math.ceil(date.diff(endOfWeek, 'weeks', true)) + 1;\n }\n\n /**\n * Return the number of weeks in the given month\n *\n * As there is no fixed standard to specify which month a partial week should\n * belongs to, the ISO week date standard is used, where:\n * - the first week of the month should have at least 4 days\n *\n * @see https://en.wikipedia.org/wiki/ISO_week_date\n *\n * @param {Timestamp | dayjs.Dayjs} d Datejs object or timestamp\n * @return {number} The number of weeks\n */\n getWeeksCountInMonth(d: Timestamp | dayjs.Dayjs): number {\n const pivotDate = this.date(d);\n\n return (\n this.getLastWeekOfMonth(pivotDate).diff(\n this.getFirstWeekOfMonth(pivotDate),\n 'week',\n ) + 1\n );\n }\n\n /**\n * Return the start of the first week of the month\n *\n * @see getWeeksCountInMonth() about standard warning\n * @return {dayjs.Dayjs} A dayjs object representing the start of the\n * first week\n */\n getFirstWeekOfMonth(d: Timestamp | dayjs.Dayjs): dayjs.Dayjs {\n const startOfMonth = this.date(d).startOf('month');\n let startOfFirstWeek = startOfMonth.startOf('week');\n if (startOfMonth.weekday() > 4) {\n startOfFirstWeek = startOfFirstWeek.add(1, 'week');\n }\n\n return startOfFirstWeek;\n }\n\n /**\n * Return the end of the last week of the month\n *\n * @see getWeeksCountInMonth() about standard warning\n * @return {dayjs.Dayjs} A dayjs object representing the end of the last week\n */\n getLastWeekOfMonth(d: Timestamp | dayjs.Dayjs): dayjs.Dayjs {\n const endOfMonth = this.date(d).endOf('month');\n let endOfLastWeek = endOfMonth.endOf('week');\n if (endOfMonth.weekday() < 4) {\n endOfLastWeek = endOfLastWeek.subtract(1, 'week');\n }\n\n return endOfLastWeek;\n }\n\n date(d: Timestamp | Date | dayjs.Dayjs | string = new Date()): dayjs.Dayjs {\n if (dayjs.isDayjs(d)) {\n return d;\n }\n\n return dayjs(d)\n .tz(this.timezone)\n .utcOffset(0)\n .locale(this.locale as (typeof Ls)[0] | string);\n }\n\n format(\n timestamp: Timestamp,\n formatter: null | string | Function,\n ...args: any\n ): string | null {\n if (typeof formatter === 'function') {\n return formatter(timestamp, ...args);\n }\n\n if (typeof formatter === 'string') {\n return this.date(timestamp).format(formatter);\n }\n\n return null;\n }\n\n /**\n * Return an array of time interval\n *\n * @param {number|Date} date A random date included in the wanted interval\n * @param {number|Date} range Length of the wanted interval, or a stop date.\n * @param {boolean} range Whether the end date should be excluded\n * from the result\n * @returns {Array} Array of unix timestamp, in milliseconds\n */\n intervals(\n interval: DomainType,\n date: Timestamp | Date | dayjs.Dayjs,\n range: number | Date | dayjs.Dayjs,\n excludeEnd: boolean = true,\n ): Timestamp[] {\n let start = this.date(date);\n let end: dayjs.Dayjs;\n if (typeof range === 'number') {\n end = start.add(range, interval as ManipulateType);\n } else if (dayjs.isDayjs(range)) {\n end = range;\n } else {\n end = this.date(range);\n }\n\n start = start.startOf(interval as ManipulateType);\n\n end = end.startOf(interval as ManipulateType);\n let pivot = dayjs.min(start, end)!;\n end = dayjs.max(start, end)!;\n const result: Timestamp[] = [];\n\n if (!excludeEnd) {\n end = end.add(1, 'second');\n }\n\n do {\n result.push(+pivot);\n pivot = pivot.add(1, interval as ManipulateType);\n } while (pivot < end);\n\n return result;\n }\n\n // this function will work cross-browser for loading scripts asynchronously\n // eslint-disable-next-line class-methods-use-this\n loadBrowserLocale(userLocale: string): Promise {\n return new Promise((resolve, reject) => {\n const s = document.createElement('script');\n s.type = 'text/javascript';\n s.async = true;\n s.src = `https://cdn.jsdelivr.net/npm/dayjs@1/locale/${userLocale}.js`;\n s.onerror = (err) => {\n reject(err);\n };\n s.onload = () => {\n resolve((window as any)[`dayjs_locale_${userLocale}`]);\n };\n document.head.appendChild(s);\n });\n }\n\n // eslint-disable-next-line class-methods-use-this\n loadNodeLocale(userLocale: string): Promise {\n return import(`dayjs/locale/${userLocale}.js`);\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar notARegExp = require('../internals/not-a-regexp');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\nvar correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');\n\nvar stringIndexOf = uncurryThis(''.indexOf);\n\n// `String.prototype.includes` method\n// https://tc39.es/ecma262/#sec-string.prototype.includes\n$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, {\n includes: function includes(searchString /* , position = 0 */) {\n return !!~stringIndexOf(\n toString(requireObjectCoercible(this)),\n toString(notARegExp(searchString)),\n arguments.length > 1 ? arguments[1] : undefined\n );\n }\n});\n","import type TemplateCollection from '../TemplateCollection';\nimport type { DomainOptions, SubDomainOptions, DataOptions } from './Options';\nimport type { DomainType } from '../index';\n\nconst ALLOWED_DATA_TYPES = ['json', 'csv', 'tsv', 'txt'];\n\n/**\n * Ensure that critical options are valid\n *\n * @throw {Error} on critical invalid options\n * @return {boolean} Returns true when there is not critical errors\n */\nexport default function validate(\n templateCollection: TemplateCollection,\n {\n domain,\n subDomain,\n data,\n }: {\n domain: Partial;\n subDomain: Partial;\n data: Partial;\n },\n): boolean {\n const domainType = domain.type as DomainType;\n const subDomainType = subDomain.type as string;\n\n if (!templateCollection.has(domainType)) {\n throw new Error(`'${domainType}' is not a valid domain type'`);\n }\n\n if (!templateCollection.has(subDomainType)) {\n throw new Error(`'${subDomainType}' is not a valid subDomain type'`);\n }\n\n if (data.type && !ALLOWED_DATA_TYPES.includes(data.type)) {\n throw new Error(`The data type '${data.type}' is not valid data type`);\n }\n\n if (\n !(templateCollection.get(subDomainType).allowedDomainType || []).includes(\n domainType,\n )\n ) {\n throw new Error(\n `The subDomain.type '${subDomainType}' can not be used together ` +\n `with the domain type ${domainType}`,\n );\n }\n\n return true;\n}\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Set` constructor\n// https://tc39.es/ecma262/#sec-set-objects\ncollection('Set', function (init) {\n return function Set() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","import isEqual from 'lodash-es/isEqual';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport {\n PluginDefinition,\n PluginOptions,\n IPluginContructor,\n IPlugin,\n} from '../index';\n\ntype PluginSetting = {\n options?: PluginOptions;\n dirty: boolean;\n};\n\nfunction createPlugin(\n Creator: IPluginContructor,\n calendar: CalHeatmap,\n): IPlugin {\n return new Creator(calendar);\n}\n\nfunction extractPluginName(\n PluginClass: IPluginContructor,\n options?: PluginOptions,\n): string {\n return `${new PluginClass().name}${options?.key || ''}`;\n}\n\nexport default class PluginManager {\n calendar: CalHeatmap;\n\n settings: Map;\n\n plugins: Map;\n\n pendingPaint: Set;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.settings = new Map();\n this.plugins = new Map();\n this.pendingPaint = new Set();\n }\n\n add(plugins: PluginDefinition[]): void {\n plugins.forEach(([PluginClass, pluginOptions]) => {\n const name = extractPluginName(PluginClass, pluginOptions);\n\n const existingPlugin = this.plugins.get(name);\n\n if (\n existingPlugin &&\n this.settings.get(name) &&\n isEqual(this.settings.get(name)!.options, pluginOptions)\n ) {\n return;\n }\n\n this.settings.set(name, {\n options: pluginOptions,\n dirty: true,\n });\n\n if (!this.plugins.has(name)) {\n this.plugins.set(name, createPlugin(PluginClass, this.calendar));\n }\n\n this.pendingPaint.add(this.plugins.get(name)!);\n });\n }\n\n setupAll(): void {\n this.plugins.forEach((pluginInstance, name) => {\n const settings = this.settings.get(name);\n\n if (typeof settings !== 'undefined') {\n if (settings.dirty) {\n pluginInstance.setup(settings.options);\n settings.dirty = false;\n\n this.settings.set(name, settings);\n }\n }\n });\n }\n\n paintAll(): Promise[] {\n return Array.from(this.pendingPaint.values()).map((p) => p.paint());\n }\n\n destroyAll(): Promise[] {\n return this.allPlugins().map((p) => p.destroy());\n }\n\n getFromPosition(position: PluginOptions['position']): IPlugin[] {\n return this.allPlugins().filter(\n (plugin) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n plugin.options?.position === position,\n );\n }\n\n getHeightFromPosition(position: PluginOptions['position']): number {\n return this.getFromPosition(position)\n .map((d) => d.options.dimensions!.height)\n .reduce((a, b) => a + b, 0);\n }\n\n getWidthFromPosition(position: PluginOptions['position']): number {\n return this.getFromPosition(position)\n .map((d) => d.options.dimensions!.width)\n .reduce((a, b) => a + b, 0);\n }\n\n allPlugins(): IPlugin[] {\n return Array.from(this.plugins.values());\n }\n}\n","import minuteTemplate from './minute';\nimport hourTemplate from './hour';\nimport dayTemplate from './day';\nimport xDayTemplate from './xDay';\nimport ghDayTemplate from './ghDay';\nimport weekTemplate from './week';\nimport monthTemplate from './month';\nimport yearTemplate from './year';\n\nexport default [\n minuteTemplate,\n hourTemplate,\n dayTemplate,\n xDayTemplate,\n ghDayTemplate,\n weekTemplate,\n monthTemplate,\n yearTemplate,\n];\n","import type { Template, DomainType } from '../index';\n\nconst minuteTemplate: Template = (DateHelper) => {\n const COLUMNS_COUNT = 10;\n const ROWS_COUNT = 6;\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['day', 'hour'];\n\n return {\n name: 'minute',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => COLUMNS_COUNT,\n columnsCount: () => ROWS_COUNT,\n mapping: (startTimestamp, endTimestamp) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n DateHelper.intervals(\n 'minute',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts, index: number) => ({\n t: ts,\n x: Math.floor(index / COLUMNS_COUNT),\n y: index % COLUMNS_COUNT,\n })),\n extractUnit: (ts) => DateHelper.date(ts).startOf('minute').valueOf(),\n };\n};\n\nexport default minuteTemplate;\n","import type { DomainOptions } from '../options/Options';\nimport type { Template, DomainType } from '../index';\n\nconst hourTemplate: Template = (\n DateHelper,\n { domain }: { domain: DomainOptions },\n) => {\n const TOTAL_ITEMS = 24;\n const ROWS_COUNT = 6;\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['month', 'week', 'day'];\n\n return {\n name: 'hour',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => ROWS_COUNT,\n columnsCount: (ts) => {\n switch (domain.type) {\n case 'week':\n return (TOTAL_ITEMS / ROWS_COUNT) * 7;\n case 'month':\n return (\n (TOTAL_ITEMS / ROWS_COUNT) *\n (domain.dynamicDimension ? DateHelper.date(ts).daysInMonth() : 31)\n );\n case 'day':\n default:\n return TOTAL_ITEMS / ROWS_COUNT;\n }\n },\n mapping: (startTimestamp, endTimestamp) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n DateHelper.intervals(\n 'hour',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts) => {\n const date = DateHelper.date(ts);\n const hour = date.hour();\n const monthDate = date.date();\n let baseX = Math.floor(hour / ROWS_COUNT);\n const columnOffset = TOTAL_ITEMS / ROWS_COUNT;\n\n if (domain.type === 'month') {\n baseX += (monthDate - 1) * columnOffset;\n }\n if (domain.type === 'week') {\n baseX += +date.format('d') * columnOffset;\n }\n\n return {\n t: ts,\n x: baseX,\n y: Math.floor(hour % ROWS_COUNT),\n };\n }),\n extractUnit: (ts) => DateHelper.date(ts).startOf('hour').valueOf(),\n };\n};\n\nexport default hourTemplate;\n","import type { OptionsType, DomainOptions } from '../options/Options';\nimport type { Template, DomainType } from '../index';\n\nconst dayTemplate: Template = (\n DateHelper,\n {\n domain,\n verticalOrientation,\n }: {\n domain: DomainOptions;\n verticalOrientation: OptionsType['verticalOrientation'];\n },\n) => {\n const ROWS_COUNT = 7;\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['year', 'month', 'week'];\n\n return {\n name: 'day',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => (domain.type === 'week' ? 1 : ROWS_COUNT),\n columnsCount: (ts) => {\n switch (domain.type) {\n case 'month':\n return Math.ceil(\n domain.dynamicDimension && !verticalOrientation ?\n DateHelper.getMonthWeekNumber(\n DateHelper.date(ts).endOf('month'),\n ) :\n 6, // In rare case, when the first week contains less than 3 days\n );\n case 'year':\n return Math.ceil(\n domain.dynamicDimension ?\n DateHelper.date(ts).endOf('year').dayOfYear() / ROWS_COUNT :\n 54,\n );\n case 'week':\n default:\n return ROWS_COUNT;\n }\n },\n mapping: (startTimestamp, endTimestamp) => {\n let weekNumber = 0;\n let x = -1;\n\n return DateHelper.intervals(\n 'day',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts) => {\n const date = DateHelper.date(ts);\n\n switch (domain.type) {\n case 'month':\n x = DateHelper.getMonthWeekNumber(ts) - 1;\n break;\n case 'year':\n if (weekNumber !== date.week()) {\n weekNumber = date.week();\n x += 1;\n }\n break;\n case 'week':\n x = date.weekday();\n break;\n default:\n }\n\n return {\n t: ts,\n x,\n y: domain.type === 'week' ? 0 : date.weekday(),\n };\n });\n },\n extractUnit: (ts) => DateHelper.date(ts).startOf('day').valueOf(),\n };\n};\n\nexport default dayTemplate;\n","import type { OptionsType, DomainOptions } from '../options/Options';\nimport type { Template, DomainType } from '../index';\n\nconst dayTemplate: Template = (\n DateHelper,\n {\n domain,\n verticalOrientation,\n }: {\n domain: DomainOptions;\n verticalOrientation: OptionsType['verticalOrientation'];\n },\n) => {\n const COLUMNS_COUNT = 7;\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['year', 'month', 'week'];\n\n return {\n name: 'xDay',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: (ts) => {\n switch (domain.type) {\n case 'month':\n return Math.ceil(\n domain.dynamicDimension && !verticalOrientation ?\n DateHelper.getMonthWeekNumber(\n DateHelper.date(ts).endOf('month'),\n ) :\n 6, // In rare case, when the first week contains less than 3 days\n );\n case 'year':\n return Math.ceil(\n domain.dynamicDimension ?\n DateHelper.date(ts).endOf('year').dayOfYear() / COLUMNS_COUNT :\n 54,\n );\n case 'week':\n default:\n return COLUMNS_COUNT;\n }\n },\n columnsCount: () => {\n if (domain.type === 'week') {\n return 1;\n }\n return COLUMNS_COUNT;\n },\n mapping: (startTimestamp, endTimestamp) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n DateHelper.intervals(\n 'day',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts) => {\n const date = DateHelper.date(ts);\n const endWeekNumber = date.endOf('year').week();\n let x = 0;\n\n switch (domain.type) {\n case 'month':\n x = DateHelper.getMonthWeekNumber(ts) - 1;\n break;\n case 'year':\n if (endWeekNumber === 1 && date.week() === endWeekNumber) {\n x = date.subtract(1, 'week').week() + 1;\n }\n\n x = date.week() - 1;\n break;\n case 'week':\n x = date.weekday();\n break;\n default:\n }\n\n return {\n t: ts,\n y: x,\n x: domain.type === 'week' ? 0 : date.weekday(),\n };\n }),\n extractUnit: (ts) => DateHelper.date(ts).startOf('day').valueOf(),\n };\n};\n\nexport default dayTemplate;\n","import type { Template, DomainType } from '../index';\n\nconst dayTemplate: Template = (DateHelper) => {\n const ROWS_COUNT = 7;\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['month'];\n\n return {\n name: 'ghDay',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => ROWS_COUNT,\n columnsCount: (ts) => DateHelper.getWeeksCountInMonth(ts),\n mapping: (startTimestamp, endTimestamp) => {\n const clampStart = DateHelper.getFirstWeekOfMonth(startTimestamp);\n const clampEnd = DateHelper.getFirstWeekOfMonth(endTimestamp);\n\n let x = -1;\n const pivotDay = clampStart.weekday();\n\n return DateHelper.intervals('day', clampStart, clampEnd).map((ts) => {\n const weekday = DateHelper.date(ts).weekday();\n if (weekday === pivotDay) {\n x += 1;\n }\n\n return {\n t: ts,\n x,\n y: weekday,\n };\n });\n },\n extractUnit: (ts) => DateHelper.date(ts).startOf('day').valueOf(),\n };\n};\n\nexport default dayTemplate;\n","import type { DomainOptions } from '../options/Options';\nimport type { Template, DomainType } from '../index';\n\nconst weekTemplate: Template = (\n DateHelper,\n { domain }: { domain: DomainOptions },\n) => {\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['year', 'month'];\n\n return {\n name: 'week',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => 1,\n columnsCount: (ts) => {\n switch (domain.type) {\n case 'year':\n return domain.dynamicDimension ?\n DateHelper.date(ts).endOf('year').isoWeeksInYear() :\n 53;\n case 'month':\n return domain.dynamicDimension ?\n DateHelper.getWeeksCountInMonth(ts) :\n 5;\n default:\n return 1;\n }\n },\n mapping: (startTimestamp, endTimestamp) => {\n const clampStart = DateHelper.getFirstWeekOfMonth(startTimestamp);\n const clampEnd = DateHelper.getFirstWeekOfMonth(endTimestamp);\n\n return DateHelper.intervals('week', clampStart, clampEnd).map(\n (ts, i) => ({\n t: ts,\n x: i,\n y: 0,\n }),\n );\n },\n extractUnit: (ts) => DateHelper.date(ts).startOf('week').valueOf(),\n };\n};\n\nexport default weekTemplate;\n","import type { Template, DomainType } from '../index';\n\nconst monthTemplate: Template = (DateHelper) => {\n const ALLOWED_DOMAIN_TYPE: DomainType[] = ['year'];\n\n return {\n name: 'month',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => 1,\n columnsCount: () => 12,\n mapping: (startTimestamp, endTimestamp) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n DateHelper.intervals(\n 'month',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts) => ({\n t: ts,\n x: DateHelper.date(ts).month(),\n y: 0,\n })),\n extractUnit: (ts) => DateHelper.date(ts).startOf('month').valueOf(),\n };\n};\n\nexport default monthTemplate;\n","import type { Template, DomainType } from '../index';\n\nconst yearTemplate: Template = (DateHelper) => {\n const ALLOWED_DOMAIN_TYPE: DomainType[] = [];\n\n return {\n name: 'year',\n allowedDomainType: ALLOWED_DOMAIN_TYPE,\n rowsCount: () => 1,\n columnsCount: () => 1,\n mapping: (startTimestamp, endTimestamp) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n DateHelper.intervals(\n 'year',\n startTimestamp,\n DateHelper.date(endTimestamp),\n ).map((ts, index) => ({\n t: ts,\n x: index,\n y: 0,\n })),\n extractUnit: (ts) => DateHelper.date(ts).startOf('year').valueOf(),\n };\n};\n\nexport default yearTemplate;\n","import castArray from 'lodash-es/castArray';\n\nimport DefaultTemplates from './templates/index';\nimport type Options from './options/Options';\nimport type { Template, TemplateResult } from './index';\nimport type DateHelper from './helpers/DateHelper';\n\nexport default class TemplateCollection {\n dateHelper: DateHelper;\n\n options: Options;\n\n settings: Map;\n\n // Whether the default templates has been initiated\n initiated: boolean;\n\n constructor(dateHelper: DateHelper, options: Options) {\n this.settings = new Map();\n this.dateHelper = dateHelper;\n this.options = options;\n this.initiated = false;\n }\n\n get(subDomainType: string): TemplateResult {\n return this.settings.get(subDomainType)!;\n }\n\n has(subDomainType: string): boolean {\n return this.settings.has(subDomainType);\n }\n\n init() {\n if (!this.initiated) {\n this.initiated = true;\n this.add(DefaultTemplates);\n }\n }\n\n add(templates: Template | Template[]) {\n this.init();\n\n const tplWithParent: string[] = [];\n castArray(templates).forEach((f) => {\n const template = f(this.dateHelper, this.options.options);\n this.settings.set(template.name, template);\n\n if (template.hasOwnProperty('parent')) {\n tplWithParent.push(template.name);\n }\n });\n\n tplWithParent.forEach((name) => {\n const parentTemplate = this.settings.get(\n this.settings.get(name)!.parent!,\n );\n\n if (!parentTemplate) {\n return;\n }\n\n this.settings.set(name, {\n ...parentTemplate,\n ...this.settings.get(name),\n });\n });\n }\n}\n","import EventEmmiter from 'eventemitter3';\nimport castArray from 'lodash-es/castArray';\nimport type { PluginFunc } from 'dayjs';\nimport type dayjs from 'dayjs';\n\nimport Navigator from './calendar/Navigator';\nimport CalendarPainter from './calendar/CalendarPainter';\nimport Populator from './calendar/Populator';\nimport Options from './options/Options';\nimport DataFetcher from './DataFetcher';\nimport DomainCollection from './calendar/DomainCollection';\nimport DateHelper from './helpers/DateHelper';\nimport validate from './options/OptionsValidator';\nimport PluginManager from './plugins/PluginManager';\nimport VERSION from './version';\n\nimport './cal-heatmap.scss';\n\nimport TemplateCollection from './TemplateCollection';\n\nimport type { OptionsType } from './options/Options';\nimport type {\n Template,\n Dimensions,\n PluginDefinition,\n Timestamp,\n} from './index';\n\nimport { ScrollDirection } from './constant';\n\nexport default class CalHeatmap {\n static VERSION = VERSION;\n\n options: Options;\n\n calendarPainter: CalendarPainter;\n\n populator: Populator;\n\n navigator: Navigator;\n\n eventEmitter: EventEmmiter;\n\n dataFetcher: DataFetcher;\n\n domainCollection!: DomainCollection;\n\n templateCollection: TemplateCollection;\n\n dateHelper: DateHelper;\n\n pluginManager: PluginManager;\n\n constructor() {\n // Default options\n this.options = new Options();\n\n // Init the helpers with the default options\n this.dateHelper = new DateHelper();\n this.templateCollection = new TemplateCollection(\n this.dateHelper,\n this.options,\n );\n this.dataFetcher = new DataFetcher(this);\n this.navigator = new Navigator(this);\n this.populator = new Populator(this);\n\n this.calendarPainter = new CalendarPainter(this);\n this.eventEmitter = new EventEmmiter();\n this.pluginManager = new PluginManager(this);\n }\n\n createDomainCollection(\n startDate: Timestamp | Date,\n range: number | Date,\n excludeEnd: boolean = true,\n ): DomainCollection {\n return new DomainCollection(\n this.dateHelper,\n this.options.options.domain.type,\n startDate,\n range,\n excludeEnd,\n );\n }\n\n // =========================================================================\n // PUBLIC API\n // =========================================================================\n\n /**\n * Setup and paint the calendar with the given options\n *\n * @param {Object} options The Options object\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n async paint(\n options?: CalHeatmap.DeepPartial,\n plugins?: PluginDefinition[] | PluginDefinition,\n ): Promise {\n this.options.init(options);\n await this.dateHelper.setup(this.options);\n\n this.templateCollection.init();\n\n try {\n validate(this.templateCollection, this.options.options);\n } catch (error) {\n return Promise.reject(error);\n }\n\n if (plugins) {\n this.pluginManager.add(castArray(plugins as any) as PluginDefinition[]);\n }\n\n this.calendarPainter.setup();\n\n // Record all the valid domains\n // Each domain value is a timestamp in milliseconds\n this.domainCollection = new DomainCollection(this.dateHelper);\n this.navigator.loadNewDomains(\n this.createDomainCollection(\n this.options.options.date.start,\n this.options.options.range,\n ),\n );\n\n return Promise.allSettled([this.calendarPainter.paint(), this.fill()]);\n }\n\n /**\n * Add a new subDomainTemplate\n *\n * @since 4.0.0\n * @param {SubDomainTemplate[] | SubDomainTemplate} templates\n * A single, or an array of SubDomainTemplate object\n * @return void\n */\n addTemplates(templates: Template | Template[]): void {\n this.templateCollection.add(templates);\n }\n\n /**\n * Shift the calendar by n domains forward\n *\n * @param {number} n Number of domain intervals to shift forward\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n next(n: number = 1): Promise {\n const loadDirection = this.navigator.loadNewDomains(\n this.createDomainCollection(this.domainCollection.max, n + 1).slice(n),\n ScrollDirection.SCROLL_FORWARD,\n );\n\n return Promise.allSettled([\n this.calendarPainter.paint(loadDirection),\n this.fill(),\n ]);\n }\n\n /**\n * Shift the calendar by n domains backward\n *\n * @param {number} n Number of domain intervals to shift backward\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n previous(n: number = 1): Promise {\n const loadDirection = this.navigator.loadNewDomains(\n this.createDomainCollection(this.domainCollection.min, -n),\n ScrollDirection.SCROLL_BACKWARD,\n );\n\n return Promise.allSettled([\n this.calendarPainter.paint(loadDirection),\n this.fill(),\n ]);\n }\n\n /**\n * Jump directly to a specific date\n *\n * JumpTo will scroll the calendar until the wanted domain with the specified\n * date is visible. Unless you set reset to true, the wanted domain\n * will not necessarily be the first domain of the calendar.\n *\n * @param {Date} date Jump to the domain containing that date\n * @param {boolean} reset Whether the wanted domain\n * should be the first domain of the calendar\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n jumpTo(date: Date, reset: boolean = false): Promise {\n return Promise.allSettled([\n this.calendarPainter.paint(this.navigator.jumpTo(date, reset)),\n this.fill(),\n ]);\n }\n\n /**\n * Fill the calendar with the given data\n *\n * @param {Object|string} dataSource The calendar's datasource,\n * same type as `options.data.source`\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n fill(dataSource = this.options.options.data.source): Promise {\n const { options } = this.options;\n const template = this.templateCollection;\n const endDate = this.dateHelper.intervals(\n options.domain.type,\n this.domainCollection.max,\n 2,\n )[1];\n\n const dataPromise = this.dataFetcher.getDatas(\n dataSource,\n this.domainCollection.min,\n endDate,\n );\n\n return new Promise((resolve, reject) => {\n dataPromise.then(\n (data: any) => {\n this.domainCollection.fill(\n data,\n options.data,\n template.get(options.subDomain.type)!.extractUnit,\n );\n this.populator.populate();\n resolve(null);\n },\n (error) => {\n reject(error);\n },\n );\n });\n }\n\n /**\n * Listener for all events\n *\n * @since 4.0.0\n * @param {string} eventName Name of the event to listen to\n * @param {function} Callback function to execute on event trigger\n * @return void\n */\n on(name: string, fn: (...args: any[]) => any): void {\n this.eventEmitter.on(name, fn);\n }\n\n dimensions(): Dimensions {\n return this.calendarPainter.dimensions;\n }\n\n /**\n * Destroy the calendar\n *\n * @since 3.3.6\n * @return A Promise, which will fulfill once all the underlying asynchronous\n * tasks settle, whether resolved or rejected.\n */\n destroy(): Promise {\n return this.calendarPainter.destroy();\n }\n\n extendDayjs(plugin: PluginFunc): dayjs.Dayjs {\n return this.dateHelper.extend(plugin);\n }\n}\n","const VERSION = '4.2.4';\nexport default VERSION;\n"],"names":["check","it","Math","global","globalThis","window","self","this","Function","shared$4","exports","require$$0","defineProperty","Object","defineGlobalProperty","key","value","configurable","writable","error","require$$1","SHARED","sharedStore","store","sharedModule","undefined","push","version","mode","copyright","license","source","match","fails","exec","functionBindNative","test","bind","hasOwnProperty","NATIVE_BIND","FunctionPrototype","prototype","call","uncurryThisWithBind","functionUncurryThis","fn","apply","arguments","isNullOrUndefined","$TypeError","TypeError","requireObjectCoercible","$Object","toObject","argument","hasOwnProperty_1","hasOwn","uncurryThis","id","postfix","random","toString","uid","engineUserAgent","navigator","String","userAgent","process","Deno","versions","v8","split","engineV8Version","V8_VERSION","$String","require$$2","symbolConstructorDetection","getOwnPropertySymbols","symbol","Symbol","sham","useSymbolAsUid","iterator","shared","require$$3","NATIVE_SYMBOL","require$$4","USE_SYMBOL_AS_UID","require$$5","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","wellKnownSymbol","name","toStringTagSupport","documentAll","document","all","documentAll_1","IS_HTMLDDA","isCallable","objectDefineProperty","descriptors","get","isObject","EXISTS","createElement","documentCreateElement","ie8DomDefine","a","v8PrototypeDefineBug","anObject","functionCall","getBuiltIn","namespace","method","length","objectIsPrototypeOf","isPrototypeOf","isSymbol","$Symbol","tryToString","aCallable","getMethod","V","P","func","ordinaryToPrimitive","input","pref","val","valueOf","TO_PRIMITIVE","toPrimitive","result","exoticToPrim","toPropertyKey","DESCRIPTORS","IE8_DOM_DEFINE","V8_PROTOTYPE_DEFINE_BUG","$defineProperty","$getOwnPropertyDescriptor","getOwnPropertyDescriptor","ENUMERABLE","CONFIGURABLE","WRITABLE","f","O","Attributes","current","enumerable","makeBuiltIn$3","getDescriptor","functionName","PROPER","functionToString","inspectSource","set","has","WeakMap","weakMapBasicDetection","createPropertyDescriptor","bitmap","definePropertyModule","createNonEnumerableProperty","object","keys","sharedKey","hiddenKeys","NATIVE_WEAK_MAP","require$$6","require$$7","OBJECT_ALREADY_INITIALIZED","state","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","CONFIGURABLE_FUNCTION_NAME","enforceInternalState","getInternalState","stringSlice","slice","replace","join","CONFIGURABLE_LENGTH","TEMPLATE","makeBuiltIn","makeBuiltInModule","options","getter","setter","arity","constructor","defineBuiltIn","simple","unsafe","nonConfigurable","nonWritable","classofRaw","TO_STRING_TAG_SUPPORT","TO_STRING_TAG","CORRECT_ARGUMENTS","classof","tag","tryGet","callee","objectGetOwnPropertyDescriptor","objectPropertyIsEnumerable","$propertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","descriptor","indexedObject","IndexedObject","toIndexedObject","propertyIsEnumerableModule","objectGetOwnPropertyNames","ceil","floor","trunc","x","n","toIntegerOrInfinity","number","max","min","toAbsoluteIndex","index","integer","toLength","lengthOfArrayLike","obj","createMethod","IS_INCLUDES","$this","el","fromIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","i","enumBugKeys","internalObjectKeys","concat","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","ownKeys","getOwnPropertyDescriptorModule","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","toLowerCase","isForced_1","copyConstructorProperties","target","exceptions","_export","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","engineIsNode","uncurryThisAccessor","aPossiblePrototype","objectSetPrototypeOf","setPrototypeOf","CORRECT_SETTER","Array","proto","__proto__","setToStringTag","TAG","defineBuiltInAccessor","SPECIES","setSpecies","CONSTRUCTOR_NAME","Constructor","anInstance","Prototype","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","$location","defer","channel","port","isConstructor","called","aConstructor","functionApply","Reflect","functionUncurryThisClause","functionBindContext","that","html","arraySlice","engineIsIos","require$$8","validateArgumentsLength","passed","required","IS_IOS","require$$10","IS_NODE","require$$11","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","location","run","runner","eventListener","event","globalPostMessageDefer","postMessage","protocol","host","handler","args","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","task","Queue","head","tail","add","item","entry","next","notify","toggle","node","promise","then","engineIsIosPebble","Pebble","engineIsWebosWebkit","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","Promise","queueMicrotaskDescriptor","microtask","flush","parent","domain","exit","enter","resolve","createTextNode","observe","characterData","microtask_1","perform","promiseNativeConstructor","engineIsDeno","engineIsBrowser","NativePromiseConstructor","IS_BROWSER","IS_DENO","require$$9","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","promiseConstructorDetection","CONSTRUCTOR","REJECTION_EVENT","newPromiseCapability$2","PromiseCapability","C","reject","$$resolve","$$reject","newPromiseCapability","Internal","OwnPromiseCapability","nativeThen","$","require$$12","speciesConstructor","defaultConstructor","S","require$$14","require$$15","hostReportErrors","b","console","require$$17","require$$18","InternalStateModule","require$$19","require$$20","newPromiseCapabilityModule","require$$22","PROMISE","require$$21","NATIVE_PROMISE_SUBCLASSING","getInternalPromiseState","setInternalState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","isThenable","callReaction","reaction","exited","ok","fail","rejection","onHandleUnhandled","isReject","notified","reactions","onUnhandled","reason","initEvent","isUnhandled","emit","unwrap","internalReject","done","internalResolve","wrapper","executor","onFulfilled","onRejected","PromiseWrapper","wrap","iterators","Iterators","ITERATOR","ArrayPrototype","isArrayIteratorMethod","getIteratorMethod","getIterator","usingIterator","iteratorMethod","iteratorClose","kind","innerResult","innerError","Result","stopped","ResultPrototype","iterate","iterable","unboundFunction","iterFn","step","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","SAFE_CLOSING","iteratorWithReturn","return","from","checkCorrectnessOfIteration","SKIP_CLOSING","ITERATION_SUPPORT","promiseStaticsIncorrectIteration","capability","$promiseResolve","values","remaining","alreadyCalled","real","catch","race","r","promiseResolve","promiseCapability","objectDefineProperties","objectKeys","defineProperties","Properties","props","activeXDocument","definePropertiesModule","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","style","display","src","contentWindow","open","F","objectCreate","create","UNSCOPABLES","IteratorPrototype","PrototypeOfArrayIteratorPrototype","arrayIterator","addToUnscopables","correctPrototypeGetter","getPrototypeOf","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","objectGetPrototypeOf","BUGGY_SAFARI_ITERATORS","NEW_ITERATOR_PROTOTYPE","iteratorsCore","returnThis","createIteratorConstructor","IteratorConstructor","NAME","ENUMERABLE_NEXT","PROPER_FUNCTION_NAME","require$$13","KEYS","VALUES","ENTRIES","iteratorDefine","Iterable","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","createIterResultObject","defineIterator","ARRAY_ITERATOR","es_array_iterator","iterated","Arguments","allSettled","status","charAt","charCodeAt","CONVERT_TO_STRING","pos","first","second","position","size","stringMultibyte","codeAt","STRING_ITERATOR","point","domIterables","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DOMTokenList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","classList","DOMTokenListPrototype","domTokenListPrototype","DOMIterables","ArrayIteratorMethods","ArrayValues","handlePrototype","CollectionPrototype","COLLECTION_NAME","METHOD_NAME","fill","argumentsLength","end","endPos","isArray","createProperty","propertyKey","arrayMethodHasSpeciesSupport","array","foo","Boolean","nativeSlice","HAS_SPECIES_SUPPORT","$Array","__awaiter","thisArg","_arguments","generator","fulfilled","e","rejected","__classPrivateFieldGet","receiver","start","k","fin","prefix","Events","EE","context","once","addListener","emitter","listener","evt","_events","_eventsCount","clearEvent","EventEmitter","eventNames","events","listeners","handlers","l","ee","listenerCount","a1","a2","a3","a4","a5","len","removeListener","j","on","removeAllListeners","off","prefixed","module","isArray$3","castArray","arraySpeciesConstructor","originalArray","arraySpeciesCreate","IS_MAP","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_REJECT","NO_HOLES","callbackfn","specificCreate","boundFunction","arrayIteration","forEach","map","filter","some","every","find","findIndex","filterReject","$map","$assign","assign","objectAssign","A","B","alphabet","chr","T","internalMetadata","objectGetOwnPropertyNamesExternal","arraySliceSimple","$getOwnPropertyNames","windowNames","getWindowNames","arrayBufferNonExtensible","ArrayBuffer","buffer","isExtensible","ARRAY_BUFFER_NON_EXTENSIBLE","$isExtensible","objectIsExtensible","freezing","preventExtensions","getOwnPropertyNamesExternalModule","FREEZING","REQUIRED","METADATA","setMetadata","objectID","weakData","meta","internalMetadataModule","enable","splice","fastKey","getWeakData","onFreeze","InternalMetadataModule","inheritIfRequired","dummy","Wrapper","NewTarget","NewTargetPrototype","collection","common","IS_WEAK","ADDER","NativeConstructor","NativePrototype","exported","fixMethod","uncurriedNativeMethod","getConstructor","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","setStrong","defineBuiltIns","internalStateGetterFor","uncaughtFrozenStore","frozen","UncaughtFrozenStore","findUncaughtFrozen","delete","ScrollDirection","Position","collectionWeak","define","init","SCALE_BASE_OPACITY_COLOR","SCALE_BASE_COLOR_DOMAIN","Navigator","calendar","_classCallCheck","maxDomainReached","minDomainReached","_createClass","newDomainCollection","_this","direction","SCROLL_NONE","templatesClt","templateCollection","minDate","date","extractUnit","maxDate","domainCollection","_Navigator_instances","_Navigator_isDomainBoundaryReached","clamp","range","SCROLL_FORWARD","merge","domainKey","subDomainEndDate","at","dateHelper","intervals","pop","subDomain","mapping","d","v","defaultValue","_Navigator_setDomainsBoundaryReached","SCROLL_BACKWARD","eventEmitter","reset","_this$calendar","Date","loadNewDomains","createDomainCollection","WeakSet","lowerBound","upperBound","reached","doesNotExceedSafeInteger","IS_CONCAT_SPREADABLE","IS_CONCAT_SPREADABLE_SUPPORT","isConcatSpreadable","spreadable","arg","E","arrayMethodIsStrict","nativeJoin","separator","collectionStrong","last","previous","getEntry","removed","prev","ITERATOR_NAME","getInternalCollectionState","getInternalIteratorState","mergeSort","comparefn","middle","insertionSort","element","left","right","llength","rlength","lindex","rindex","arraySort","firefox","engineFfVersion","engineIsIeOrEdge","webkit","engineWebkitVersion","deletePropertyOrThrow","internalSort","FF","IE_OR_EDGE","V8","WEBKIT","nativeSort","sort","FAILS_ON_UNDEFINED","FAILS_ON_NULL","STRICT_METHOD","STABLE_SORT","code","fromCharCode","itemsLength","items","arrayLength","y","getSortCompare","$forEach","arrayForEach","isVertical","horizontalPadding","padding","LEFT","RIGHT","verticalPadding","TOP","BOTTOM","DomainCoordinates","domainPainter","Map","scrollDirection","_this$calendar$option","verticalOrientation","dimensions","width","height","exitingTotal","scrollFactor","reverse","yankedDomains","coor","w","_DomainCoordinates_instances","_DomainCoordinates_getWidth","h","_DomainCoordinates_getHeight","pre_x","pre_y","inner_width","gutter","inner_height","_this$calendar$option2","columnsCount","subDomainWidth","domainHorizontalLabelWidth","_this$calendar$option3","rowsCount","subDomainHeight","domainVerticalLabelHeight","DEFAULT_SELECTOR","DomainPainter","coordinates","root","rootNode","animationDuration","t","transition","duration","update","promises","selectAll","append","attr","enterSelection","updateSelection","exitSelection","remove","classname","helper","hour","format","week","month","year","$includes","$filter","callWithSafeIterationClosing","arrayLike","IS_CONSTRUCTOR","mapfn","DOMAIN_FORMAT","xDay","ghDay","day","minute","DomainCollection","interval","excludeEnd","ts","_DomainCollection_instances","_DomainCollection_refreshKeys","callback","newCollection","limit","createValueCallback","_this2","keyToRemove","_this3","fromBeginning","_ref","subDomainKeyExtractor","_this4","groupY","groupedRecords","groupRecords","records","_DomainCollection_setSubDomainValues","_this5","results","validSubDomainTimestamp","timestamp","extractTimestamp","groupFn","cleanedValues","reduce","_toConsumableArray","datum","extractorFn","_this6","groupValues","_DomainCollection_extractValues","parseInt","DomainLabelPainter","label","text","textAlign","_DomainLabelPainter_instances","_DomainLabelPainter_textVerticalAlign","nodes","selection","_DomainLabelPainter_domainRotate","rotate","_this$calendar$option4","offset","_DomainLabelPainter_getDomainInsideWidth","_this$calendar$option5","_this$calendar$option6","_this$calendar$option7","_DomainLabelPainter_getDomainInsideHeight","_this$calendar$option8","calendarPainter","domainsContainerPainter","_this$calendar$option9","_this$calendar$option10","_this$calendar$option11","labelWidth","domainWidth","domainHeight","s","whitespaces","ltrim","RegExp","rtrim","stringTrim","trim","$trim","forcedStringTrimMethod","SubDomainPainter","containerClassname","subDomainSvgGroup","_SubDomainPainter_instances","_SubDomainPainter_setPositions","radius","subDomainsCollection","abs","insert","_SubDomainPainter_classname","ev","_SubDomainPainter_appendText","_options$domain","highlight","unitFn","_len","otherClasses","_key","elem","_SubDomainPainter_getCoordinates","axis","BASE_SELECTOR","TRANSITION_CLASSNAME","DomainsContainerPainter","subDomainPainter","domainLabelPainter","transitionsQueueCount","_DomainsContainerPainter_instances","_DomainsContainerPainter_startAnimation","paint","_DomainsContainerPainter_recomputeDimensions","_DomainsContainerPainter_endAnimation","_a","topHeight","pluginManager","getHeightFromPosition","leftWidth","getWidthFromPosition","select","parentNode","classed","domainsDimensions","PluginPainter","paintAll","setPluginsPosition","top","getFromPosition","bottom","topOffset","plugin","leftOffset","CalendarPainter","pluginPainter","itemSelector","theme","setup","setupAll","navigationDir","transitions","updatePosition","_CalendarPainter_instances","_CalendarPainter_resize","destroyAll","destroy","insideHeight","_CalendarPainter_getWidth","insideWidth","newWidth","newHeight","freeGlobal$1","freeSelf","root$1","freeGlobal","Symbol$2","objectProto","nativeObjectToString","symToStringTag","toStringTag","nullTag","undefinedTag","baseGetTag","isOwn","unmasked","getRawTag","objectToString","asyncTag","funcTag","genTag","proxyTag","isFunction","nativeKeys","MATCH","isRegExp","notARegexp","correctIsRegexpLogic","regexp","error1","error2","notARegExp","correctIsRegExpLogic","nativeStartsWith","startsWith","CORRECT_IS_REGEXP_LOGIC","searchString","search","IE_BUG","TO_ENTRIES","IE_WORKAROUND","$entries","defined","Number","isNaN","ascendingDefined","ascending","finite","isFinite","NaN","positive","negative","re","parse","fallback","timeIntervals","timeSecond","timeMinute","timeHour","timeDay","timeWeek","timeMonth","timeYear","timeMonday","timeTuesday","timeWednesday","timeThursday","timeFriday","timeSaturday","timeSunday","utcIntervals","utcSecond","utcMinute","utcHour","utcDay","utcWeek","utcMonth","utcYear","utcMonday","utcTuesday","utcWednesday","utcThursday","utcFriday","utcSaturday","utcSunday","maybeTimeInterval","Error","maybeUtcInterval","TypedArray","Uint8Array","constant","coerceNumbers","coerceNumber","Float64Array","coerceDates","coerceDate","isoParse","arrayify","isScaleOptions","option","maybeInterval","isInteger","lo","hi","rangei","maybeRangeInterval","isOrdinal","isTemporal","isTemporalString","isNumericString","orderof","descending","color","opacity","registry","sqrt4_3","sqrt","symbolHexagon","draw","rx","PI","ry","hy","moveTo","lineTo","closePath","symbols","symbolAsterisk","symbolCircle","symbolCross","symbolDiamond","symbolDiamond2","symbolPlus","symbolSquare","symbolSquare2","symbolStar","symbolTimes","symbolTriangle","symbolTriangle2","symbolWye","maybeSymbol","isSymbolObject","warn","message","ordinalSchemes","schemeAccent","schemeCategory10","schemeDark2","schemePaired","schemePastel1","schemePastel2","schemeSet1","schemeSet2","schemeSet3","schemeTableau10","scheme11","schemeBrBG","interpolateBrBG","schemePRGn","interpolatePRGn","schemePiYG","interpolatePiYG","schemePuOr","interpolatePuOr","schemeRdBu","interpolateRdBu","schemeRdGy","interpolateRdGy","schemeRdYlBu","interpolateRdYlBu","schemeRdYlGn","interpolateRdYlGn","schemeSpectral","interpolateSpectral","scheme11r","scheme9","schemeBlues","interpolateBlues","schemeGreens","interpolateGreens","schemeGreys","interpolateGreys","schemeOranges","interpolateOranges","schemePurples","interpolatePurples","schemeReds","interpolateReds","schemei","interpolateTurbo","interpolateViridis","interpolateMagma","interpolateInferno","interpolatePlasma","interpolateCividis","interpolateCubehelixDefault","interpolateWarm","interpolateCool","schemeBuGn","interpolateBuGn","schemeBuPu","interpolateBuPu","schemeGnBu","interpolateGnBu","schemeOrRd","interpolateOrRd","schemePuBu","interpolatePuBu","schemePuBuGn","interpolatePuBuGn","schemePuRd","interpolatePuRd","schemeRdPu","interpolateRdPu","schemeYlGn","interpolateYlGn","schemeYlGnBu","interpolateYlGnBu","schemeYlOrBr","interpolateYlOrBr","schemeYlOrRd","interpolateYlOrRd","schemeicyclical","interpolateRainbow","interpolateSinebow","scheme","interpolate","quantize","ordinalScheme","ordinalRange","quantitativeSchemes","quantitativeScheme","divergingSchemes","Set","isDivergingScheme","flip","unit","interpolators","interpolateNumber","interpolateRgb","interpolateHsl","interpolateHcl","interpolateLab","maybeInterpolator","createScaleQ","scale","channels","nice","zero","inferAutoDomain","unknown","round","inferRadialRange","inferLengthRange","interpolateRound","_","interpolatePiecewise","extent","sign","reverseof","maybeNiceInterval","maybeNice","createScalePow","exponent","scalePow","createScaleThreshold","isOrdered","scaleThreshold","inferDomain","inferZeroDomain","hint","h25","quantile","h50","median","inferLogDomain","inferQuantileDomain","createScaleD","transform","pivot","symmetric","piecewise","mid","mindelta","maxdelta","invert","interpolator","createScaleDivergingPow","scaleDivergingPow","transformSqrt","pow","transformPow","createScaleDivergingSymlog","scaleDivergingSymlog","log1p","expm1","transformSymlog","transformIdentity","transformLog","log","exp","createScaleT","ordinalImplicit","createScaleO","createScaleOrdinal","inferHint","stroke","inferSymbolHint","isNone","symbolsStroke","symbolsFill","inferSymbolRange","maybeBooleanRange","t0","scaleImplicit","scaleOrdinal","maybeRound","InternSet","candidate","normalizeScale","projection","typeProjection","asOrdinalType","inferScaleType","isOrdinalScale","formatScaleType","coerceType","coerceSymbols","scaleDiverging","createScaleDiverging","createScaleDivergingSqrt","base","scaleDivergingLog","createScaleDivergingLog","scaleLinear","createScaleLinear","createScaleSqrt","quantiles","scaleQuantile","createScaleQuantile","thresholds","ticks","createScaleQuantize","scaleLog","createScaleLog","scaleSymlog","createScaleSymlog","scaleUtc","createScaleUtc","scaleTime","createScaleTime","align","scalePoint","createScalePoint","paddingInner","paddingOuter","scaleBand","createScaleBand","scaleIdentity","createScale","description","coerceValues","c","exposeScale","percent","bandwidth","normalizedScale","scaleOptions","scaleType","applyScaleStyle","_scale","keyname","styles","baseColor","scaleStyle","_ref2","_slicedToArray","prop","Populator","_calendar$options$opt","colorScale","defaultColor","hcl","eq","other","assocIndexOf","ListCache","__data__","coreJsData$1","maskSrcKey","coreJsData","funcToString","toSource","reIsHostCtor","funcProto","reIsNative","baseIsNative","getNative","getValue","Map$2","nativeCreate$1","Hash","getMapData","MapCache","nativeCreate","hash","Stack","pairs","LARGE_ARRAY_SIZE","defineProperty$1","baseAssignValue","assignMergeValue","fromRight","baseFor","iteratee","keysFunc","baseFor$1","freeExports","nodeType","freeModule","Buffer","allocUnsafe","Uint8Array$2","cloneTypedArray","typedArray","isDeep","arrayBuffer","byteLength","byteOffset","baseCreate$1","overArg","getPrototype$1","isPrototype","Ctor","isObjectLike","baseIsArguments","isArguments","isArguments$1","MAX_SAFE_INTEGER","isLength","isArrayLike","isBuffer$1","isBuffer","objectTag","objectCtorString","typedArrayTags","freeProcess","nodeUtil","types","require","binding","nodeIsTypedArray","isTypedArray","isTypedArray$1","safeGet","assignValue","objValue","reIsUint","isIndex","arrayLikeKeys","inherited","isArr","isArg","isBuff","isType","skipIndexes","baseTimes","baseKeysIn","nativeKeysIn","isProto","keysIn","toPlainObject","customizer","isNew","newValue","copyObject","baseMergeDeep","srcIndex","mergeFunc","stack","srcValue","stacked","isCommon","isTyped","copyArray","copy","cloneBuffer","getPrototype","isPlainObject","baseCreate","initCloneObject","baseMerge","identity","nativeMax","baseSetToString","baseSetToString$1","nativeNow","setToString","count","lastCalled","stamp","shortOut","setToString$1","baseRest","otherArgs","overRest","assigner","mergeWith","sources","guard","isIterateeCall","mergeWith$1","SetCache","arraySome","predicate","COMPARE_PARTIAL_FLAG","COMPARE_UNORDERED_FLAG","equalArrays","bitmask","equalFunc","isPartial","arrLength","othLength","arrStacked","othStacked","seen","arrValue","othValue","compared","othIndex","mapToArray","setToArray","boolTag","dateTag","errorTag","mapTag","numberTag","regexpTag","setTag","stringTag","symbolTag","arrayBufferTag","dataViewTag","symbolProto","symbolValueOf","nativeGetSymbols","getSymbols","resIndex","arrayFilter","getSymbols$1","nativeKeys$1","baseKeys","getAllKeys","symbolsFunc","arrayPush","baseGetAllKeys","DataView$1","Promise$2","Set$2","WeakMap$1","promiseTag","weakMapTag","dataViewCtorString","DataView","mapCtorString","promiseCtorString","setCtorString","weakMapCtorString","getTag","ctorString","getTag$1","argsTag","arrayTag","baseIsEqualDeep","objIsArr","othIsArr","objTag","othTag","objIsObj","othIsObj","isSameTag","convert","equalByTag","objIsWrapped","othIsWrapped","objUnwrapped","othUnwrapped","objProps","objLength","objStacked","skipCtor","objCtor","othCtor","equalObjects","baseIsEqual","isEqual","baseHas","reIsDeepProp","reIsPlainProp","FUNC_ERROR_TEXT","memoize","resolver","memoized","cache","Cache","rePropName","reEscapeChar","stringToPath","memoizeCapped","quote","subString","stringToPath$1","INFINITY","symbolToString","baseToString","arrayMap","castPath","isKey","toKey","path","hasFunc","hasPath","baseGet","lastIndex","nested","baseSet","re1","re2","OptionsPreProcessors","isString","Options","processors","preProcessors","dynamicDimension","locale","timezone","requestInit","opts","initScale","$RegExp","UNSUPPORTED_Y","MISSED_STICKY","sticky","BROKEN_CARET","regexpStickyHelpers","regexpUnsupportedDotAll","dotAll","flags","regexpUnsupportedNcg","groups","regexpFlags","hasIndices","ignoreCase","multiline","unicode","unicodeSets","stickyHelpers","UNSUPPORTED_DOT_ALL","UNSUPPORTED_NCG","nativeReplace","nativeExec","patchedExec","UPDATES_LAST_INDEX_WRONG","NPCG_INCLUDED","reCopy","group","str","raw","charsAdded","strCopy","regexpExec","RegExpPrototype","SUBSTITUTION_SYMBOLS","SUBSTITUTION_SYMBOLS_NO_NAMED","fixRegExpWellKnownSymbolLogic","SHAM","SYMBOL","DELEGATES_TO_SYMBOL","DELEGATES_TO_EXEC","execCalled","uncurriedNativeRegExpMethod","nativeMethod","arg2","forceStringMethod","$exec","advanceStringIndex","getSubstitution","matched","captures","namedCaptures","tailPos","m","ch","capture","regExpExec","R","REPLACE","require$$16","stringIndexOf","REPLACE_KEEPS_$0","REGEXP_REPLACE_SUBSTITUTES_UNDEFINED_CAPTURE","REPLACE_SUPPORTS_NAMED_GROUPS","maybeCallNative","UNSAFE_SUBSTITUTE","searchValue","replaceValue","replacer","res","functionalReplace","fullUnicode","accumulatedResult","nextSourcePosition","replacerArgs","DataFetcher","startTimestamp","endTimestamp","_context","abrupt","_DataFetcher_instances","_DataFetcher_fetch","_callee","newUri","url","parseURI","json","csv","dsv","FUNCTION_NAME_EXISTS","nameRE","dayjs_min","u","o","M","weekdays","months","ordinal","z","utcOffset","clone","p","D","ms","Q","g","$L","utc","$u","$x","$offset","$d","substring","UTC","$y","getFullYear","$M","getMonth","$D","getDate","$W","getDay","$H","getHours","$m","getMinutes","$s","getSeconds","$ms","getMilliseconds","$utils","isValid","isSame","startOf","endOf","isAfter","isBefore","$g","unix","getTime","toDate","$locale","weekStart","$set","daysInMonth","subtract","invalidDate","meridiem","monthsShort","weekdaysMin","weekdaysShort","getTimezoneOffset","diff","toJSON","toISOString","toUTCString","extend","$i","isDayjs","en","Ls","yearStart","weeks","dayOfYear","weekday","isoWeeksInYear","isLeapYear","isoWeekday","isoWeekYear","isoWeek","weekYear","offsetName","local","getUTCFullYear","getUTCMonth","getUTCDate","getUTCDay","getUTCHours","getUTCMinutes","getUTCSeconds","getUTCMilliseconds","$localOffset","isUTC","timeZoneName","Intl","DateTimeFormat","hour12","timeZone","formatToParts","tz","toLocaleString","$timezone","guess","resolvedOptions","setDefault","formats","toUpperCase","firstDayOfWeek","longDateFormat","localeData","LTS","L","LL","LLL","LLLL","updateLocale","dayjs","weekOfYear","minMax","advancedFormat","localizedFormat","DEFAULT_LOCALE","DateHelper","_typeof","userLocale","loadBrowserLocale","sent","loadNodeLocale","dayjsPlugin","dayjsDate","endOfWeek","pivotDate","getLastWeekOfMonth","getFirstWeekOfMonth","startOfMonth","startOfFirstWeek","endOfMonth","endOfLastWeek","formatter","async","onerror","err","onload","import","ALLOWED_DATA_TYPES","validate","domainType","subDomainType","allowedDomainType","PluginManager","settings","plugins","pendingPaint","Creator","PluginClass","pluginOptions","extractPluginName","dirty","pluginInstance","allPlugins","TOTAL_ITEMS","monthDate","baseX","getMonthWeekNumber","weekNumber","endWeekNumber","getWeeksCountInMonth","clampStart","clampEnd","pivotDay","TemplateCollection","initiated","DefaultTemplates","templates","tplWithParent","template","parentTemplate","CalHeatmap","dataFetcher","populator","EventEmmiter","startDate","loadDirection","jumpTo","dataSource","endDate","dataPromise","getDatas","populate","VERSION"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,159,161,162,163,164,165,166,167,168,169,170,171,172,173,174,178,179,180,181,182,185,186,187,188,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,355,356,358,359,360,361,362,363,364,365,366,367,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,385,387]} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.esm.js b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.esm.js new file mode 100644 index 0000000..5f9c8c6 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.esm.js @@ -0,0 +1,3793 @@ +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } +} +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; +} +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); +} +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); +} + +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +var fails$j = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + +var fails$i = fails$j; + +// Detect IE8's incomplete defineProperty implementation +var descriptors = !fails$i(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; +}); + +var fails$h = fails$j; + +var functionBindNative = !fails$h(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); +}); + +var NATIVE_BIND$3 = functionBindNative; + +var FunctionPrototype$3 = Function.prototype; +var call$e = FunctionPrototype$3.call; +var uncurryThisWithBind = NATIVE_BIND$3 && FunctionPrototype$3.bind.bind(call$e, call$e); + +var functionUncurryThis = NATIVE_BIND$3 ? uncurryThisWithBind : function (fn) { + return function () { + return call$e.apply(fn, arguments); + }; +}; + +// we can't use just `it == null` since of `document.all` special case +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec +var isNullOrUndefined$6 = function (it) { + return it === null || it === undefined; +}; + +var isNullOrUndefined$5 = isNullOrUndefined$6; + +var $TypeError$c = TypeError; + +// `RequireObjectCoercible` abstract operation +// https://tc39.es/ecma262/#sec-requireobjectcoercible +var requireObjectCoercible$3 = function (it) { + if (isNullOrUndefined$5(it)) throw new $TypeError$c("Can't call method on " + it); + return it; +}; + +var requireObjectCoercible$2 = requireObjectCoercible$3; + +var $Object$4 = Object; + +// `ToObject` abstract operation +// https://tc39.es/ecma262/#sec-toobject +var toObject$5 = function (argument) { + return $Object$4(requireObjectCoercible$2(argument)); +}; + +var uncurryThis$l = functionUncurryThis; +var toObject$4 = toObject$5; + +var hasOwnProperty = uncurryThis$l({}.hasOwnProperty); + +// `HasOwnProperty` abstract operation +// https://tc39.es/ecma262/#sec-hasownproperty +// eslint-disable-next-line es/no-object-hasown -- safe +var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject$4(it), key); +}; + +var DESCRIPTORS$b = descriptors; +var hasOwn$b = hasOwnProperty_1; + +var FunctionPrototype$2 = Function.prototype; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getDescriptor = DESCRIPTORS$b && Object.getOwnPropertyDescriptor; + +var EXISTS$1 = hasOwn$b(FunctionPrototype$2, 'name'); +// additional protection from minified / mangled / dropped function names +var PROPER = EXISTS$1 && (function something() { /* empty */ }).name === 'something'; +var CONFIGURABLE$1 = EXISTS$1 && (!DESCRIPTORS$b || (DESCRIPTORS$b && getDescriptor(FunctionPrototype$2, 'name').configurable)); + +var functionName = { + EXISTS: EXISTS$1, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE$1 +}; + +var makeBuiltIn$3 = {exports: {}}; + +var documentAll$2 = typeof document == 'object' && document.all; + +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot +// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing +var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined; + +var documentAll_1 = { + all: documentAll$2, + IS_HTMLDDA: IS_HTMLDDA +}; + +var $documentAll$1 = documentAll_1; + +var documentAll$1 = $documentAll$1.all; + +// `IsCallable` abstract operation +// https://tc39.es/ecma262/#sec-iscallable +var isCallable$m = $documentAll$1.IS_HTMLDDA ? function (argument) { + return typeof argument == 'function' || argument === documentAll$1; +} : function (argument) { + return typeof argument == 'function'; +}; + +var check = function (it) { + return it && it.Math === Math && it; +}; + +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +var global$k = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + +var global$j = global$k; + +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty$7 = Object.defineProperty; + +var defineGlobalProperty$3 = function (key, value) { + try { + defineProperty$7(global$j, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$j[key] = value; + } return value; +}; + +var global$i = global$k; +var defineGlobalProperty$2 = defineGlobalProperty$3; + +var SHARED = '__core-js_shared__'; +var store$3 = global$i[SHARED] || defineGlobalProperty$2(SHARED, {}); + +var sharedStore = store$3; + +var uncurryThis$k = functionUncurryThis; +var isCallable$l = isCallable$m; +var store$2 = sharedStore; + +var functionToString$1 = uncurryThis$k(Function.toString); + +// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper +if (!isCallable$l(store$2.inspectSource)) { + store$2.inspectSource = function (it) { + return functionToString$1(it); + }; +} + +var inspectSource$3 = store$2.inspectSource; + +var global$h = global$k; +var isCallable$k = isCallable$m; + +var WeakMap$1 = global$h.WeakMap; + +var weakMapBasicDetection = isCallable$k(WeakMap$1) && /native code/.test(String(WeakMap$1)); + +var isCallable$j = isCallable$m; +var $documentAll = documentAll_1; + +var documentAll = $documentAll.all; + +var isObject$e = $documentAll.IS_HTMLDDA ? function (it) { + return typeof it == 'object' ? it !== null : isCallable$j(it) || it === documentAll; +} : function (it) { + return typeof it == 'object' ? it !== null : isCallable$j(it); +}; + +var objectDefineProperty = {}; + +var global$g = global$k; +var isObject$d = isObject$e; + +var document$3 = global$g.document; +// typeof document.createElement is 'object' in old IE +var EXISTS = isObject$d(document$3) && isObject$d(document$3.createElement); + +var documentCreateElement$2 = function (it) { + return EXISTS ? document$3.createElement(it) : {}; +}; + +var DESCRIPTORS$a = descriptors; +var fails$g = fails$j; +var createElement$1 = documentCreateElement$2; + +// Thanks to IE8 for its funny defineProperty +var ie8DomDefine = !DESCRIPTORS$a && !fails$g(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { + get: function () { return 7; } + }).a !== 7; +}); + +var DESCRIPTORS$9 = descriptors; +var fails$f = fails$j; + +// V8 ~ Chrome 36- +// https://bugs.chromium.org/p/v8/issues/detail?id=3334 +var v8PrototypeDefineBug = DESCRIPTORS$9 && fails$f(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; +}); + +var isObject$c = isObject$e; + +var $String$5 = String; +var $TypeError$b = TypeError; + +// `Assert: Type(argument) is Object` +var anObject$b = function (argument) { + if (isObject$c(argument)) return argument; + throw new $TypeError$b($String$5(argument) + ' is not an object'); +}; + +var NATIVE_BIND$2 = functionBindNative; + +var call$d = Function.prototype.call; + +var functionCall = NATIVE_BIND$2 ? call$d.bind(call$d) : function () { + return call$d.apply(call$d, arguments); +}; + +var global$f = global$k; +var isCallable$i = isCallable$m; + +var aFunction = function (argument) { + return isCallable$i(argument) ? argument : undefined; +}; + +var getBuiltIn$7 = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$f[namespace]) : global$f[namespace] && global$f[namespace][method]; +}; + +var uncurryThis$j = functionUncurryThis; + +var objectIsPrototypeOf = uncurryThis$j({}.isPrototypeOf); + +var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || ''; + +var global$e = global$k; +var userAgent$3 = engineUserAgent; + +var process$3 = global$e.process; +var Deno$1 = global$e.Deno; +var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version; +var v8 = versions && versions.v8; +var match, version; + +if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); +} + +// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` +// so check `userAgent` even if `.v8` exists, but 0 +if (!version && userAgent$3) { + match = userAgent$3.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$3.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } +} + +var engineV8Version = version; + +/* eslint-disable es/no-symbol -- required for testing */ +var V8_VERSION$1 = engineV8Version; +var fails$e = fails$j; +var global$d = global$k; + +var $String$4 = global$d.String; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing +var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$e(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String$4(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$1 && V8_VERSION$1 < 41; +}); + +/* eslint-disable es/no-symbol -- required for testing */ +var NATIVE_SYMBOL$1 = symbolConstructorDetection; + +var useSymbolAsUid = NATIVE_SYMBOL$1 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + +var getBuiltIn$6 = getBuiltIn$7; +var isCallable$h = isCallable$m; +var isPrototypeOf$2 = objectIsPrototypeOf; +var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + +var $Object$3 = Object; + +var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + var $Symbol = getBuiltIn$6('Symbol'); + return isCallable$h($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it)); +}; + +var $String$3 = String; + +var tryToString$4 = function (argument) { + try { + return $String$3(argument); + } catch (error) { + return 'Object'; + } +}; + +var isCallable$g = isCallable$m; +var tryToString$3 = tryToString$4; + +var $TypeError$a = TypeError; + +// `Assert: IsCallable(argument) is true` +var aCallable$8 = function (argument) { + if (isCallable$g(argument)) return argument; + throw new $TypeError$a(tryToString$3(argument) + ' is not a function'); +}; + +var aCallable$7 = aCallable$8; +var isNullOrUndefined$4 = isNullOrUndefined$6; + +// `GetMethod` abstract operation +// https://tc39.es/ecma262/#sec-getmethod +var getMethod$3 = function (V, P) { + var func = V[P]; + return isNullOrUndefined$4(func) ? undefined : aCallable$7(func); +}; + +var call$c = functionCall; +var isCallable$f = isCallable$m; +var isObject$b = isObject$e; + +var $TypeError$9 = TypeError; + +// `OrdinaryToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-ordinarytoprimitive +var ordinaryToPrimitive$1 = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable$f(fn = input.toString) && !isObject$b(val = call$c(fn, input))) return val; + if (isCallable$f(fn = input.valueOf) && !isObject$b(val = call$c(fn, input))) return val; + if (pref !== 'string' && isCallable$f(fn = input.toString) && !isObject$b(val = call$c(fn, input))) return val; + throw new $TypeError$9("Can't convert object to primitive value"); +}; + +var shared$3 = {exports: {}}; + +var store$1 = sharedStore; + +(shared$3.exports = function (key, value) { + return store$1[key] || (store$1[key] = value !== undefined ? value : {}); +})('versions', []).push({ + version: '3.34.0', + mode: 'global', + copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE', + source: 'https://github.com/zloirock/core-js' +}); + +var sharedExports = shared$3.exports; + +var uncurryThis$i = functionUncurryThis; + +var id$2 = 0; +var postfix = Math.random(); +var toString$5 = uncurryThis$i(1.0.toString); + +var uid$3 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$5(++id$2 + postfix, 36); +}; + +var global$c = global$k; +var shared$2 = sharedExports; +var hasOwn$a = hasOwnProperty_1; +var uid$2 = uid$3; +var NATIVE_SYMBOL = symbolConstructorDetection; +var USE_SYMBOL_AS_UID = useSymbolAsUid; + +var Symbol$1 = global$c.Symbol; +var WellKnownSymbolsStore = shared$2('wks'); +var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$2; + +var wellKnownSymbol$f = function (name) { + if (!hasOwn$a(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$a(Symbol$1, name) + ? Symbol$1[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; +}; + +var call$b = functionCall; +var isObject$a = isObject$e; +var isSymbol$1 = isSymbol$2; +var getMethod$2 = getMethod$3; +var ordinaryToPrimitive = ordinaryToPrimitive$1; +var wellKnownSymbol$e = wellKnownSymbol$f; + +var $TypeError$8 = TypeError; +var TO_PRIMITIVE = wellKnownSymbol$e('toPrimitive'); + +// `ToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-toprimitive +var toPrimitive$1 = function (input, pref) { + if (!isObject$a(input) || isSymbol$1(input)) return input; + var exoticToPrim = getMethod$2(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$b(exoticToPrim, input, pref); + if (!isObject$a(result) || isSymbol$1(result)) return result; + throw new $TypeError$8("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); +}; + +var toPrimitive = toPrimitive$1; +var isSymbol = isSymbol$2; + +// `ToPropertyKey` abstract operation +// https://tc39.es/ecma262/#sec-topropertykey +var toPropertyKey$3 = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; +}; + +var DESCRIPTORS$8 = descriptors; +var IE8_DOM_DEFINE$1 = ie8DomDefine; +var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug; +var anObject$a = anObject$b; +var toPropertyKey$2 = toPropertyKey$3; + +var $TypeError$7 = TypeError; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var $defineProperty = Object.defineProperty; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; +var ENUMERABLE = 'enumerable'; +var CONFIGURABLE = 'configurable'; +var WRITABLE = 'writable'; + +// `Object.defineProperty` method +// https://tc39.es/ecma262/#sec-object.defineproperty +objectDefineProperty.f = DESCRIPTORS$8 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) { + anObject$a(O); + P = toPropertyKey$2(P); + anObject$a(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor$1(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); +} : $defineProperty : function defineProperty(O, P, Attributes) { + anObject$a(O); + P = toPropertyKey$2(P); + anObject$a(Attributes); + if (IE8_DOM_DEFINE$1) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$7('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + +var createPropertyDescriptor$4 = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + +var DESCRIPTORS$7 = descriptors; +var definePropertyModule$4 = objectDefineProperty; +var createPropertyDescriptor$3 = createPropertyDescriptor$4; + +var createNonEnumerableProperty$5 = DESCRIPTORS$7 ? function (object, key, value) { + return definePropertyModule$4.f(object, key, createPropertyDescriptor$3(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + +var shared$1 = sharedExports; +var uid$1 = uid$3; + +var keys = shared$1('keys'); + +var sharedKey$3 = function (key) { + return keys[key] || (keys[key] = uid$1(key)); +}; + +var hiddenKeys$5 = {}; + +var NATIVE_WEAK_MAP = weakMapBasicDetection; +var global$b = global$k; +var isObject$9 = isObject$e; +var createNonEnumerableProperty$4 = createNonEnumerableProperty$5; +var hasOwn$9 = hasOwnProperty_1; +var shared = sharedStore; +var sharedKey$2 = sharedKey$3; +var hiddenKeys$4 = hiddenKeys$5; + +var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; +var TypeError$2 = global$b.TypeError; +var WeakMap = global$b.WeakMap; +var set$1, get, has; + +var enforce = function (it) { + return has(it) ? get(it) : set$1(it, {}); +}; + +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject$9(it) || (state = get(it)).type !== TYPE) { + throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; +}; + +if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set$1 = function (it, metadata) { + if (store.has(it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get = function (it) { + return store.get(it) || {}; + }; + has = function (it) { + return store.has(it); + }; +} else { + var STATE = sharedKey$2('state'); + hiddenKeys$4[STATE] = true; + set$1 = function (it, metadata) { + if (hasOwn$9(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty$4(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn$9(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn$9(it, STATE); + }; +} + +var internalState = { + set: set$1, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor +}; + +var uncurryThis$h = functionUncurryThis; +var fails$d = fails$j; +var isCallable$e = isCallable$m; +var hasOwn$8 = hasOwnProperty_1; +var DESCRIPTORS$6 = descriptors; +var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE; +var inspectSource$2 = inspectSource$3; +var InternalStateModule$4 = internalState; + +var enforceInternalState = InternalStateModule$4.enforce; +var getInternalState$2 = InternalStateModule$4.get; +var $String$2 = String; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty$6 = Object.defineProperty; +var stringSlice$2 = uncurryThis$h(''.slice); +var replace = uncurryThis$h(''.replace); +var join = uncurryThis$h([].join); + +var CONFIGURABLE_LENGTH = DESCRIPTORS$6 && !fails$d(function () { + return defineProperty$6(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; +}); + +var TEMPLATE = String(String).split('String'); + +var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) { + if (stringSlice$2($String$2(name), 0, 7) === 'Symbol(') { + name = '[' + replace($String$2(name), /^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn$8(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) { + if (DESCRIPTORS$6) defineProperty$6(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn$8(options, 'arity') && value.length !== options.arity) { + defineProperty$6(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn$8(options, 'constructor') && options.constructor) { + if (DESCRIPTORS$6) defineProperty$6(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn$8(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; +}; + +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +// eslint-disable-next-line no-extend-native -- required +Function.prototype.toString = makeBuiltIn$2(function toString() { + return isCallable$e(this) && getInternalState$2(this).source || inspectSource$2(this); +}, 'toString'); + +var makeBuiltInExports = makeBuiltIn$3.exports; + +var makeBuiltIn$1 = makeBuiltInExports; +var defineProperty$5 = objectDefineProperty; + +var defineBuiltInAccessor$2 = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn$1(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn$1(descriptor.set, name, { setter: true }); + return defineProperty$5.f(target, name, descriptor); +}; + +var DESCRIPTORS$5 = descriptors; +var FUNCTION_NAME_EXISTS = functionName.EXISTS; +var uncurryThis$g = functionUncurryThis; +var defineBuiltInAccessor$1 = defineBuiltInAccessor$2; + +var FunctionPrototype$1 = Function.prototype; +var functionToString = uncurryThis$g(FunctionPrototype$1.toString); +var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; +var regExpExec = uncurryThis$g(nameRE.exec); +var NAME = 'name'; + +// Function instances `.name` property +// https://tc39.es/ecma262/#sec-function-instances-name +if (DESCRIPTORS$5 && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor$1(FunctionPrototype$1, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); +} + +var objectGetOwnPropertyDescriptor = {}; + +var objectPropertyIsEnumerable = {}; + +var $propertyIsEnumerable = {}.propertyIsEnumerable; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor; + +// Nashorn ~ JDK8 bug +var NASHORN_BUG = getOwnPropertyDescriptor$2 && !$propertyIsEnumerable.call({ 1: 2 }, 1); + +// `Object.prototype.propertyIsEnumerable` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable +objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor$2(this, V); + return !!descriptor && descriptor.enumerable; +} : $propertyIsEnumerable; + +var uncurryThis$f = functionUncurryThis; + +var toString$4 = uncurryThis$f({}.toString); +var stringSlice$1 = uncurryThis$f(''.slice); + +var classofRaw$2 = function (it) { + return stringSlice$1(toString$4(it), 8, -1); +}; + +var uncurryThis$e = functionUncurryThis; +var fails$c = fails$j; +var classof$9 = classofRaw$2; + +var $Object$2 = Object; +var split = uncurryThis$e(''.split); + +// fallback for non-array-like ES3 and non-enumerable old V8 strings +var indexedObject = fails$c(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object$2('z').propertyIsEnumerable(0); +}) ? function (it) { + return classof$9(it) === 'String' ? split(it, '') : $Object$2(it); +} : $Object$2; + +// toObject with fallback for non-array-like ES3 strings +var IndexedObject$3 = indexedObject; +var requireObjectCoercible$1 = requireObjectCoercible$3; + +var toIndexedObject$7 = function (it) { + return IndexedObject$3(requireObjectCoercible$1(it)); +}; + +var DESCRIPTORS$4 = descriptors; +var call$a = functionCall; +var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; +var createPropertyDescriptor$2 = createPropertyDescriptor$4; +var toIndexedObject$6 = toIndexedObject$7; +var toPropertyKey$1 = toPropertyKey$3; +var hasOwn$7 = hasOwnProperty_1; +var IE8_DOM_DEFINE = ie8DomDefine; + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor +objectGetOwnPropertyDescriptor.f = DESCRIPTORS$4 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$6(O); + P = toPropertyKey$1(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn$7(O, P)) return createPropertyDescriptor$2(!call$a(propertyIsEnumerableModule$1.f, O, P), O[P]); +}; + +var isCallable$d = isCallable$m; +var definePropertyModule$3 = objectDefineProperty; +var makeBuiltIn = makeBuiltInExports; +var defineGlobalProperty$1 = defineGlobalProperty$3; + +var defineBuiltIn$8 = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable$d(value)) makeBuiltIn(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty$1(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule$3.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; +}; + +var objectGetOwnPropertyNames = {}; + +var ceil = Math.ceil; +var floor = Math.floor; + +// `Math.trunc` method +// https://tc39.es/ecma262/#sec-math.trunc +// eslint-disable-next-line es/no-math-trunc -- safe +var mathTrunc = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor : ceil)(n); +}; + +var trunc = mathTrunc; + +// `ToIntegerOrInfinity` abstract operation +// https://tc39.es/ecma262/#sec-tointegerorinfinity +var toIntegerOrInfinity$3 = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); +}; + +var toIntegerOrInfinity$2 = toIntegerOrInfinity$3; + +var max$1 = Math.max; +var min$1 = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). +var toAbsoluteIndex$2 = function (index, length) { + var integer = toIntegerOrInfinity$2(index); + return integer < 0 ? max$1(integer + length, 0) : min$1(integer, length); +}; + +var toIntegerOrInfinity$1 = toIntegerOrInfinity$3; + +var min = Math.min; + +// `ToLength` abstract operation +// https://tc39.es/ecma262/#sec-tolength +var toLength$1 = function (argument) { + return argument > 0 ? min(toIntegerOrInfinity$1(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + +var toLength = toLength$1; + +// `LengthOfArrayLike` abstract operation +// https://tc39.es/ecma262/#sec-lengthofarraylike +var lengthOfArrayLike$4 = function (obj) { + return toLength(obj.length); +}; + +var toIndexedObject$5 = toIndexedObject$7; +var toAbsoluteIndex$1 = toAbsoluteIndex$2; +var lengthOfArrayLike$3 = lengthOfArrayLike$4; + +// `Array.prototype.{ indexOf, includes }` methods implementation +var createMethod$2 = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject$5($this); + var length = lengthOfArrayLike$3(O); + var index = toAbsoluteIndex$1(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod$2(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod$2(false) +}; + +var uncurryThis$d = functionUncurryThis; +var hasOwn$6 = hasOwnProperty_1; +var toIndexedObject$4 = toIndexedObject$7; +var indexOf = arrayIncludes.indexOf; +var hiddenKeys$3 = hiddenKeys$5; + +var push$1 = uncurryThis$d([].push); + +var objectKeysInternal = function (object, names) { + var O = toIndexedObject$4(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn$6(hiddenKeys$3, key) && hasOwn$6(O, key) && push$1(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn$6(O, key = names[i++])) { + ~indexOf(result, key) || push$1(result, key); + } + return result; +}; + +// IE8- don't enum bug keys +var enumBugKeys$3 = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + +var internalObjectKeys$1 = objectKeysInternal; +var enumBugKeys$2 = enumBugKeys$3; + +var hiddenKeys$2 = enumBugKeys$2.concat('length', 'prototype'); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +// eslint-disable-next-line es/no-object-getownpropertynames -- safe +objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys$2); +}; + +var objectGetOwnPropertySymbols = {}; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe +objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; + +var getBuiltIn$5 = getBuiltIn$7; +var uncurryThis$c = functionUncurryThis; +var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames; +var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; +var anObject$9 = anObject$b; + +var concat$1 = uncurryThis$c([].concat); + +// all object keys, includes non-enumerable and symbols +var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule$1.f(anObject$9(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f; + return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys; +}; + +var hasOwn$5 = hasOwnProperty_1; +var ownKeys = ownKeys$1; +var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; +var definePropertyModule$2 = objectDefineProperty; + +var copyConstructorProperties$1 = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule$2.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn$5(target, key) && !(exceptions && hasOwn$5(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } +}; + +var fails$b = fails$j; +var isCallable$c = isCallable$m; + +var replacement = /#|\.prototype\./; + +var isForced$3 = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable$c(detection) ? fails$b(detection) + : !!detection; +}; + +var normalize = isForced$3.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced$3.data = {}; +var NATIVE = isForced$3.NATIVE = 'N'; +var POLYFILL = isForced$3.POLYFILL = 'P'; + +var isForced_1 = isForced$3; + +var global$a = global$k; +var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; +var createNonEnumerableProperty$3 = createNonEnumerableProperty$5; +var defineBuiltIn$7 = defineBuiltIn$8; +var defineGlobalProperty = defineGlobalProperty$3; +var copyConstructorProperties = copyConstructorProperties$1; +var isForced$2 = isForced_1; + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key +*/ +var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global$a; + } else if (STATIC) { + target = global$a[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = (global$a[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor$1(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced$2(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty$3(sourceProperty, 'sham', true); + } + defineBuiltIn$7(target, key, sourceProperty, options); + } +}; + +var internalObjectKeys = objectKeysInternal; +var enumBugKeys$1 = enumBugKeys$3; + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +// eslint-disable-next-line es/no-object-keys -- safe +var objectKeys$2 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys$1); +}; + +var DESCRIPTORS$3 = descriptors; +var uncurryThis$b = functionUncurryThis; +var call$9 = functionCall; +var fails$a = fails$j; +var objectKeys$1 = objectKeys$2; +var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; +var propertyIsEnumerableModule = objectPropertyIsEnumerable; +var toObject$3 = toObject$5; +var IndexedObject$2 = indexedObject; + +// eslint-disable-next-line es/no-object-assign -- safe +var $assign = Object.assign; +// eslint-disable-next-line es/no-object-defineproperty -- required for testing +var defineProperty$4 = Object.defineProperty; +var concat = uncurryThis$b([].concat); + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +var objectAssign = !$assign || fails$a(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$3 && $assign({ b: 1 }, $assign(defineProperty$4({}, 'a', { + enumerable: true, + get: function () { + defineProperty$4(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys$1($assign({}, B)).join('') !== alphabet; +}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject$3(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject$2(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$3 || call$9(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; +} : $assign; + +var $$b = _export; +var assign = objectAssign; + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +// eslint-disable-next-line es/no-object-assign -- required for testing +$$b({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign +}); + +var wellKnownSymbol$d = wellKnownSymbol$f; + +var TO_STRING_TAG$2 = wellKnownSymbol$d('toStringTag'); +var test = {}; + +test[TO_STRING_TAG$2] = 'z'; + +var toStringTagSupport = String(test) === '[object z]'; + +var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; +var isCallable$b = isCallable$m; +var classofRaw$1 = classofRaw$2; +var wellKnownSymbol$c = wellKnownSymbol$f; + +var TO_STRING_TAG$1 = wellKnownSymbol$c('toStringTag'); +var $Object$1 = Object; + +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +var classof$8 = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object$1(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw$1(O) + // ES3 arguments fallback + : (result = classofRaw$1(O)) === 'Object' && isCallable$b(O.callee) ? 'Arguments' : result; +}; + +var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; +var classof$7 = classof$8; + +// `Object.prototype.toString` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.tostring +var objectToString = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$7(this) + ']'; +}; + +var TO_STRING_TAG_SUPPORT = toStringTagSupport; +var defineBuiltIn$6 = defineBuiltIn$8; +var toString$3 = objectToString; + +// `Object.prototype.toString` method +// https://tc39.es/ecma262/#sec-object.prototype.tostring +if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn$6(Object.prototype, 'toString', toString$3, { unsafe: true }); +} + +var global$9 = global$k; +var classof$6 = classofRaw$2; + +var engineIsNode = classof$6(global$9.process) === 'process'; + +var uncurryThis$a = functionUncurryThis; +var aCallable$6 = aCallable$8; + +var functionUncurryThisAccessor = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis$a(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } +}; + +var isCallable$a = isCallable$m; + +var $String$1 = String; +var $TypeError$6 = TypeError; + +var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$a(argument)) return argument; + throw new $TypeError$6("Can't set " + $String$1(argument) + ' as a prototype'); +}; + +/* eslint-disable no-proto -- safe */ +var uncurryThisAccessor = functionUncurryThisAccessor; +var anObject$8 = anObject$b; +var aPossiblePrototype = aPossiblePrototype$1; + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +// Works with __proto__ only. Old v8 can't work with null proto objects. +// eslint-disable-next-line es/no-object-setprototypeof -- safe +var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject$8(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + +var defineProperty$3 = objectDefineProperty.f; +var hasOwn$4 = hasOwnProperty_1; +var wellKnownSymbol$b = wellKnownSymbol$f; + +var TO_STRING_TAG = wellKnownSymbol$b('toStringTag'); + +var setToStringTag$5 = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$4(target, TO_STRING_TAG)) { + defineProperty$3(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + +var getBuiltIn$4 = getBuiltIn$7; +var defineBuiltInAccessor = defineBuiltInAccessor$2; +var wellKnownSymbol$a = wellKnownSymbol$f; +var DESCRIPTORS$2 = descriptors; + +var SPECIES$3 = wellKnownSymbol$a('species'); + +var setSpecies$1 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME); + + if (DESCRIPTORS$2 && Constructor && !Constructor[SPECIES$3]) { + defineBuiltInAccessor(Constructor, SPECIES$3, { + configurable: true, + get: function () { return this; } + }); + } +}; + +var isPrototypeOf$1 = objectIsPrototypeOf; + +var $TypeError$5 = TypeError; + +var anInstance$3 = function (it, Prototype) { + if (isPrototypeOf$1(Prototype, it)) return it; + throw new $TypeError$5('Incorrect invocation'); +}; + +var uncurryThis$9 = functionUncurryThis; +var fails$9 = fails$j; +var isCallable$9 = isCallable$m; +var classof$5 = classof$8; +var getBuiltIn$3 = getBuiltIn$7; +var inspectSource$1 = inspectSource$3; + +var noop = function () { /* empty */ }; +var empty = []; +var construct = getBuiltIn$3('Reflect', 'construct'); +var constructorRegExp = /^\s*(?:class|function)\b/; +var exec = uncurryThis$9(constructorRegExp.exec); +var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + +var isConstructorModern = function isConstructor(argument) { + if (!isCallable$9(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } +}; + +var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$9(argument)) return false; + switch (classof$5(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } +}; + +isConstructorLegacy.sham = true; + +// `IsConstructor` abstract operation +// https://tc39.es/ecma262/#sec-isconstructor +var isConstructor$2 = !construct || fails$9(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; +}) ? isConstructorLegacy : isConstructorModern; + +var isConstructor$1 = isConstructor$2; +var tryToString$2 = tryToString$4; + +var $TypeError$4 = TypeError; + +// `Assert: IsConstructor(argument) is true` +var aConstructor$1 = function (argument) { + if (isConstructor$1(argument)) return argument; + throw new $TypeError$4(tryToString$2(argument) + ' is not a constructor'); +}; + +var anObject$7 = anObject$b; +var aConstructor = aConstructor$1; +var isNullOrUndefined$3 = isNullOrUndefined$6; +var wellKnownSymbol$9 = wellKnownSymbol$f; + +var SPECIES$2 = wellKnownSymbol$9('species'); + +// `SpeciesConstructor` abstract operation +// https://tc39.es/ecma262/#sec-speciesconstructor +var speciesConstructor$1 = function (O, defaultConstructor) { + var C = anObject$7(O).constructor; + var S; + return C === undefined || isNullOrUndefined$3(S = anObject$7(C)[SPECIES$2]) ? defaultConstructor : aConstructor(S); +}; + +var NATIVE_BIND$1 = functionBindNative; + +var FunctionPrototype = Function.prototype; +var apply$1 = FunctionPrototype.apply; +var call$8 = FunctionPrototype.call; + +// eslint-disable-next-line es/no-reflect -- safe +var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$8.bind(apply$1) : function () { + return call$8.apply(apply$1, arguments); +}); + +var classofRaw = classofRaw$2; +var uncurryThis$8 = functionUncurryThis; + +var functionUncurryThisClause = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis$8(fn); +}; + +var uncurryThis$7 = functionUncurryThisClause; +var aCallable$5 = aCallable$8; +var NATIVE_BIND = functionBindNative; + +var bind$5 = uncurryThis$7(uncurryThis$7.bind); + +// optional / simple context binding +var functionBindContext = function (fn, that) { + aCallable$5(fn); + return that === undefined ? fn : NATIVE_BIND ? bind$5(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; +}; + +var getBuiltIn$2 = getBuiltIn$7; + +var html$2 = getBuiltIn$2('document', 'documentElement'); + +var uncurryThis$6 = functionUncurryThis; + +var arraySlice$2 = uncurryThis$6([].slice); + +var $TypeError$3 = TypeError; + +var validateArgumentsLength$1 = function (passed, required) { + if (passed < required) throw new $TypeError$3('Not enough arguments'); + return passed; +}; + +var userAgent$2 = engineUserAgent; + +// eslint-disable-next-line redos/no-vulnerable -- safe +var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2); + +var global$8 = global$k; +var apply = functionApply; +var bind$4 = functionBindContext; +var isCallable$8 = isCallable$m; +var hasOwn$3 = hasOwnProperty_1; +var fails$8 = fails$j; +var html$1 = html$2; +var arraySlice$1 = arraySlice$2; +var createElement = documentCreateElement$2; +var validateArgumentsLength = validateArgumentsLength$1; +var IS_IOS$1 = engineIsIos; +var IS_NODE$3 = engineIsNode; + +var set = global$8.setImmediate; +var clear = global$8.clearImmediate; +var process$2 = global$8.process; +var Dispatch = global$8.Dispatch; +var Function$1 = global$8.Function; +var MessageChannel = global$8.MessageChannel; +var String$1 = global$8.String; +var counter = 0; +var queue$2 = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var $location, defer, channel, port; + +fails$8(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = global$8.location; +}); + +var run = function (id) { + if (hasOwn$3(queue$2, id)) { + var fn = queue$2[id]; + delete queue$2[id]; + fn(); + } +}; + +var runner = function (id) { + return function () { + run(id); + }; +}; + +var eventListener = function (event) { + run(event.data); +}; + +var globalPostMessageDefer = function (id) { + // old engines have not location.origin + global$8.postMessage(String$1(id), $location.protocol + '//' + $location.host); +}; + +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!set || !clear) { + set = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable$8(handler) ? handler : Function$1(handler); + var args = arraySlice$1(arguments, 1); + queue$2[++counter] = function () { + apply(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue$2[id]; + }; + // Node.js 0.8- + if (IS_NODE$3) { + defer = function (id) { + process$2.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS$1) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind$4(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global$8.addEventListener && + isCallable$8(global$8.postMessage) && + !global$8.importScripts && + $location && $location.protocol !== 'file:' && + !fails$8(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + global$8.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html$1.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } +} + +var task$1 = { + set: set, + clear: clear +}; + +var Queue$2 = function () { + this.head = null; + this.tail = null; +}; + +Queue$2.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } +}; + +var queue$1 = Queue$2; + +var userAgent$1 = engineUserAgent; + +var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && typeof Pebble != 'undefined'; + +var userAgent = engineUserAgent; + +var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent); + +var global$7 = global$k; +var bind$3 = functionBindContext; +var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; +var macrotask = task$1.set; +var Queue$1 = queue$1; +var IS_IOS = engineIsIos; +var IS_IOS_PEBBLE = engineIsIosPebble; +var IS_WEBOS_WEBKIT = engineIsWebosWebkit; +var IS_NODE$2 = engineIsNode; + +var MutationObserver = global$7.MutationObserver || global$7.WebKitMutationObserver; +var document$2 = global$7.document; +var process$1 = global$7.process; +var Promise$1 = global$7.Promise; +// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` +var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$7, 'queueMicrotask'); +var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; +var notify$1, toggle, node, promise, then; + +// modern engines have queueMicrotask method +if (!microtask$1) { + var queue = new Queue$1(); + + var flush = function () { + var parent, fn; + if (IS_NODE$2 && (parent = process$1.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify$1(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { + toggle = true; + node = document$2.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify$1 = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise$1.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise$1; + then = bind$3(promise.then, promise); + notify$1 = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE$2) { + notify$1 = function () { + process$1.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind$3(macrotask, global$7); + notify$1 = function () { + macrotask(flush); + }; + } + + microtask$1 = function (fn) { + if (!queue.head) notify$1(); + queue.add(fn); + }; +} + +var microtask_1 = microtask$1; + +var hostReportErrors$1 = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } +}; + +var perform$3 = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } +}; + +var global$6 = global$k; + +var promiseNativeConstructor = global$6.Promise; + +/* global Deno -- Deno case */ +var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object'; + +var IS_DENO$1 = engineIsDeno; +var IS_NODE$1 = engineIsNode; + +var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 + && typeof window == 'object' + && typeof document == 'object'; + +var global$5 = global$k; +var NativePromiseConstructor$3 = promiseNativeConstructor; +var isCallable$7 = isCallable$m; +var isForced$1 = isForced_1; +var inspectSource = inspectSource$3; +var wellKnownSymbol$8 = wellKnownSymbol$f; +var IS_BROWSER = engineIsBrowser; +var IS_DENO = engineIsDeno; +var V8_VERSION = engineV8Version; + +NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype; +var SPECIES$1 = wellKnownSymbol$8('species'); +var SUBCLASSING = false; +var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$7(global$5.PromiseRejectionEvent); + +var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES$1] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1; +}); + +var promiseConstructorDetection = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1, + SUBCLASSING: SUBCLASSING +}; + +var newPromiseCapability$2 = {}; + +var aCallable$4 = aCallable$8; + +var $TypeError$2 = TypeError; + +var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError$2('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable$4(resolve); + this.reject = aCallable$4(reject); +}; + +// `NewPromiseCapability` abstract operation +// https://tc39.es/ecma262/#sec-newpromisecapability +newPromiseCapability$2.f = function (C) { + return new PromiseCapability(C); +}; + +var $$a = _export; +var IS_NODE = engineIsNode; +var global$4 = global$k; +var call$7 = functionCall; +var defineBuiltIn$5 = defineBuiltIn$8; +var setPrototypeOf$2 = objectSetPrototypeOf; +var setToStringTag$4 = setToStringTag$5; +var setSpecies = setSpecies$1; +var aCallable$3 = aCallable$8; +var isCallable$6 = isCallable$m; +var isObject$8 = isObject$e; +var anInstance$2 = anInstance$3; +var speciesConstructor = speciesConstructor$1; +var task = task$1.set; +var microtask = microtask_1; +var hostReportErrors = hostReportErrors$1; +var perform$2 = perform$3; +var Queue = queue$1; +var InternalStateModule$3 = internalState; +var NativePromiseConstructor$2 = promiseNativeConstructor; +var PromiseConstructorDetection = promiseConstructorDetection; +var newPromiseCapabilityModule$3 = newPromiseCapability$2; + +var PROMISE = 'Promise'; +var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR; +var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; +var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; +var getInternalPromiseState = InternalStateModule$3.getterFor(PROMISE); +var setInternalState$3 = InternalStateModule$3.set; +var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype; +var PromiseConstructor = NativePromiseConstructor$2; +var PromisePrototype = NativePromisePrototype$1; +var TypeError$1 = global$4.TypeError; +var document$1 = global$4.document; +var process = global$4.process; +var newPromiseCapability$1 = newPromiseCapabilityModule$3.f; +var newGenericPromiseCapability = newPromiseCapability$1; + +var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$4.dispatchEvent); +var UNHANDLED_REJECTION = 'unhandledrejection'; +var REJECTION_HANDLED = 'rejectionhandled'; +var PENDING = 0; +var FULFILLED = 1; +var REJECTED = 2; +var HANDLED = 1; +var UNHANDLED = 2; + +var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + +// helpers +var isThenable = function (it) { + var then; + return isObject$8(it) && isCallable$6(then = it.then) ? then : false; +}; + +var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$7(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } +}; + +var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); +}; + +var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$1.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global$4.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$4['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); +}; + +var onUnhandled = function (state) { + call$7(task, global$4, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform$2(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); +}; + +var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; +}; + +var onHandleUnhandled = function (state) { + call$7(task, global$4, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); +}; + +var bind$2 = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; +}; + +var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); +}; + +var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call$7(then, value, + bind$2(internalResolve, wrapper, state), + bind$2(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } +}; + +// constructor polyfill +if (FORCED_PROMISE_CONSTRUCTOR$4) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance$2(this, PromisePrototype); + aCallable$3(executor); + call$7(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind$2(internalResolve, state), bind$2(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState$3(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: undefined + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn$5(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable$6(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$6(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind$2(internalResolve, state); + this.reject = bind$2(internalReject, state); + }; + + newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (isCallable$6(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) { + nativeThen = NativePromisePrototype$1.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn$5(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call$7(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype$1.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf$2) { + setPrototypeOf$2(NativePromisePrototype$1, PromisePrototype); + } + } +} + +$$a({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, { + Promise: PromiseConstructor +}); + +setToStringTag$4(PromiseConstructor, PROMISE, false); +setSpecies(PROMISE); + +var iterators = {}; + +var wellKnownSymbol$7 = wellKnownSymbol$f; +var Iterators$4 = iterators; + +var ITERATOR$5 = wellKnownSymbol$7('iterator'); +var ArrayPrototype$1 = Array.prototype; + +// check on default Array iterator +var isArrayIteratorMethod$1 = function (it) { + return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$5] === it); +}; + +var classof$4 = classof$8; +var getMethod$1 = getMethod$3; +var isNullOrUndefined$2 = isNullOrUndefined$6; +var Iterators$3 = iterators; +var wellKnownSymbol$6 = wellKnownSymbol$f; + +var ITERATOR$4 = wellKnownSymbol$6('iterator'); + +var getIteratorMethod$2 = function (it) { + if (!isNullOrUndefined$2(it)) return getMethod$1(it, ITERATOR$4) + || getMethod$1(it, '@@iterator') + || Iterators$3[classof$4(it)]; +}; + +var call$6 = functionCall; +var aCallable$2 = aCallable$8; +var anObject$6 = anObject$b; +var tryToString$1 = tryToString$4; +var getIteratorMethod$1 = getIteratorMethod$2; + +var $TypeError$1 = TypeError; + +var getIterator$1 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator; + if (aCallable$2(iteratorMethod)) return anObject$6(call$6(iteratorMethod, argument)); + throw new $TypeError$1(tryToString$1(argument) + ' is not iterable'); +}; + +var call$5 = functionCall; +var anObject$5 = anObject$b; +var getMethod = getMethod$3; + +var iteratorClose$1 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$5(iterator); + try { + innerResult = getMethod(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$5(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$5(innerResult); + return value; +}; + +var bind$1 = functionBindContext; +var call$4 = functionCall; +var anObject$4 = anObject$b; +var tryToString = tryToString$4; +var isArrayIteratorMethod = isArrayIteratorMethod$1; +var lengthOfArrayLike$2 = lengthOfArrayLike$4; +var isPrototypeOf = objectIsPrototypeOf; +var getIterator = getIterator$1; +var getIteratorMethod = getIteratorMethod$2; +var iteratorClose = iteratorClose$1; + +var $TypeError = TypeError; + +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; + +var ResultPrototype = Result.prototype; + +var iterate$4 = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind$1(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject$4(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = lengthOfArrayLike$2(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call$4(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); +}; + +var wellKnownSymbol$5 = wellKnownSymbol$f; + +var ITERATOR$3 = wellKnownSymbol$5('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR$3] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +var checkCorrectnessOfIteration$2 = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR$3] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + +var NativePromiseConstructor$1 = promiseNativeConstructor; +var checkCorrectnessOfIteration$1 = checkCorrectnessOfIteration$2; +var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR; + +var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration$1(function (iterable) { + NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ }); +}); + +var $$9 = _export; +var call$3 = functionCall; +var aCallable$1 = aCallable$8; +var newPromiseCapabilityModule$2 = newPromiseCapability$2; +var perform$1 = perform$3; +var iterate$3 = iterate$4; +var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration; + +// `Promise.all` method +// https://tc39.es/ecma262/#sec-promise.all +$$9({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$2.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform$1(function () { + var $promiseResolve = aCallable$1(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$3(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$3($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var $$8 = _export; +var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR; +var NativePromiseConstructor = promiseNativeConstructor; +var getBuiltIn$1 = getBuiltIn$7; +var isCallable$5 = isCallable$m; +var defineBuiltIn$4 = defineBuiltIn$8; + +var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + +// `Promise.prototype.catch` method +// https://tc39.es/ecma262/#sec-promise.prototype.catch +$$8({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } +}); + +// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` +if (isCallable$5(NativePromiseConstructor)) { + var method = getBuiltIn$1('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn$4(NativePromisePrototype, 'catch', method, { unsafe: true }); + } +} + +var $$7 = _export; +var call$2 = functionCall; +var aCallable = aCallable$8; +var newPromiseCapabilityModule$1 = newPromiseCapability$2; +var perform = perform$3; +var iterate$2 = iterate$4; +var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration; + +// `Promise.race` method +// https://tc39.es/ecma262/#sec-promise.race +$$7({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$1.f(C); + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aCallable(C.resolve); + iterate$2(iterable, function (promise) { + call$2($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var $$6 = _export; +var call$1 = functionCall; +var newPromiseCapabilityModule = newPromiseCapability$2; +var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR; + +// `Promise.reject` method +// https://tc39.es/ecma262/#sec-promise.reject +$$6({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule.f(this); + call$1(capability.reject, undefined, r); + return capability.promise; + } +}); + +var anObject$3 = anObject$b; +var isObject$7 = isObject$e; +var newPromiseCapability = newPromiseCapability$2; + +var promiseResolve$1 = function (C, x) { + anObject$3(C); + if (isObject$7(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + +var $$5 = _export; +var getBuiltIn = getBuiltIn$7; +var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR; +var promiseResolve = promiseResolve$1; + +getBuiltIn('Promise'); + +// `Promise.resolve` method +// https://tc39.es/ecma262/#sec-promise.resolve +$$5({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(this, x); + } +}); + +var fails$7 = fails$j; + +var arrayMethodIsStrict$2 = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails$7(function () { + // eslint-disable-next-line no-useless-call -- required for testing + method.call(null, argument || function () { return 1; }, 1); + }); +}; + +var $$4 = _export; +var uncurryThis$5 = functionUncurryThis; +var IndexedObject$1 = indexedObject; +var toIndexedObject$3 = toIndexedObject$7; +var arrayMethodIsStrict$1 = arrayMethodIsStrict$2; + +var nativeJoin = uncurryThis$5([].join); + +var ES3_STRINGS = IndexedObject$1 !== Object; +var FORCED = ES3_STRINGS || !arrayMethodIsStrict$1('join', ','); + +// `Array.prototype.join` method +// https://tc39.es/ecma262/#sec-array.prototype.join +$$4({ target: 'Array', proto: true, forced: FORCED }, { + join: function join(separator) { + return nativeJoin(toIndexedObject$3(this), separator === undefined ? ',' : separator); + } +}); + +var objectDefineProperties = {}; + +var DESCRIPTORS$1 = descriptors; +var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; +var definePropertyModule$1 = objectDefineProperty; +var anObject$2 = anObject$b; +var toIndexedObject$2 = toIndexedObject$7; +var objectKeys = objectKeys$2; + +// `Object.defineProperties` method +// https://tc39.es/ecma262/#sec-object.defineproperties +// eslint-disable-next-line es/no-object-defineproperties -- safe +objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject$2(O); + var props = toIndexedObject$2(Properties); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]); + return O; +}; + +/* global ActiveXObject -- old IE, WSH */ +var anObject$1 = anObject$b; +var definePropertiesModule = objectDefineProperties; +var enumBugKeys = enumBugKeys$3; +var hiddenKeys$1 = hiddenKeys$5; +var html = html$2; +var documentCreateElement$1 = documentCreateElement$2; +var sharedKey$1 = sharedKey$3; + +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO$1 = sharedKey$1('IE_PROTO'); + +var EmptyConstructor = function () { /* empty */ }; + +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; + +// Create object with fake `null` prototype: use ActiveX Object with cleared prototype +var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; +}; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement$1('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; + +// Check for document.domain and active x support +// No need to use active x approach when document.domain is not set +// see https://github.com/es-shims/es5-shim/issues/150 +// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 +// avoid IE GC bug +var activeXDocument; +var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; + +hiddenKeys$1[IE_PROTO$1] = true; + +// `Object.create` method +// https://tc39.es/ecma262/#sec-object.create +// eslint-disable-next-line es/no-object-create -- safe +var objectCreate = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject$1(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO$1] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : definePropertiesModule.f(result, Properties); +}; + +var wellKnownSymbol$4 = wellKnownSymbol$f; +var create$1 = objectCreate; +var defineProperty$2 = objectDefineProperty.f; + +var UNSCOPABLES = wellKnownSymbol$4('unscopables'); +var ArrayPrototype = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype[UNSCOPABLES] === undefined) { + defineProperty$2(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create$1(null) + }); +} + +// add a key to Array.prototype[@@unscopables] +var addToUnscopables$1 = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; +}; + +var fails$6 = fails$j; + +var correctPrototypeGetter = !fails$6(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + +var hasOwn$2 = hasOwnProperty_1; +var isCallable$4 = isCallable$m; +var toObject$2 = toObject$5; +var sharedKey = sharedKey$3; +var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter; + +var IE_PROTO = sharedKey('IE_PROTO'); +var $Object = Object; +var ObjectPrototype = $Object.prototype; + +// `Object.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.getprototypeof +// eslint-disable-next-line es/no-object-getprototypeof -- safe +var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) { + var object = toObject$2(O); + if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable$4(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof $Object ? ObjectPrototype : null; +}; + +var fails$5 = fails$j; +var isCallable$3 = isCallable$m; +var isObject$6 = isObject$e; +var getPrototypeOf$1 = objectGetPrototypeOf; +var defineBuiltIn$3 = defineBuiltIn$8; +var wellKnownSymbol$3 = wellKnownSymbol$f; + +var ITERATOR$2 = wellKnownSymbol$3('iterator'); +var BUGGY_SAFARI_ITERATORS$1 = false; + +// `%IteratorPrototype%` object +// https://tc39.es/ecma262/#sec-%iteratorprototype%-object +var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator; + +/* eslint-disable es/no-array-prototype-keys -- safe */ +if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype; + } +} + +var NEW_ITERATOR_PROTOTYPE = !isObject$6(IteratorPrototype$2) || fails$5(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype$2[ITERATOR$2].call(test) !== test; +}); + +if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {}; + +// `%IteratorPrototype%[@@iterator]()` method +// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator +if (!isCallable$3(IteratorPrototype$2[ITERATOR$2])) { + defineBuiltIn$3(IteratorPrototype$2, ITERATOR$2, function () { + return this; + }); +} + +var iteratorsCore = { + IteratorPrototype: IteratorPrototype$2, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1 +}; + +var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; +var create = objectCreate; +var createPropertyDescriptor$1 = createPropertyDescriptor$4; +var setToStringTag$3 = setToStringTag$5; +var Iterators$2 = iterators; + +var returnThis$1 = function () { return this; }; + +var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next) }); + setToStringTag$3(IteratorConstructor, TO_STRING_TAG, false); + Iterators$2[TO_STRING_TAG] = returnThis$1; + return IteratorConstructor; +}; + +var $$3 = _export; +var call = functionCall; +var FunctionName = functionName; +var isCallable$2 = isCallable$m; +var createIteratorConstructor = iteratorCreateConstructor; +var getPrototypeOf = objectGetPrototypeOf; +var setPrototypeOf$1 = objectSetPrototypeOf; +var setToStringTag$2 = setToStringTag$5; +var createNonEnumerableProperty$2 = createNonEnumerableProperty$5; +var defineBuiltIn$2 = defineBuiltIn$8; +var wellKnownSymbol$2 = wellKnownSymbol$f; +var Iterators$1 = iterators; +var IteratorsCore = iteratorsCore; + +var PROPER_FUNCTION_NAME = FunctionName.PROPER; +var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; +var IteratorPrototype = IteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR$1 = wellKnownSymbol$2('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; + +var returnThis = function () { return this; }; + +var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND]; + + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } + + return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR$1] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf$1) { + setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$1])) { + defineBuiltIn$2(CurrentIteratorPrototype, ITERATOR$1, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag$2(CurrentIteratorPrototype, TO_STRING_TAG, true); + } + } + + // fix Array.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call(nativeIterator, this); }; + } + } + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + defineBuiltIn$2(IterablePrototype, KEY, methods[KEY]); + } + } else $$3({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if (IterablePrototype[ITERATOR$1] !== defaultIterator) { + defineBuiltIn$2(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT }); + } + Iterators$1[NAME] = defaultIterator; + + return methods; +}; + +// `CreateIterResultObject` abstract operation +// https://tc39.es/ecma262/#sec-createiterresultobject +var createIterResultObject$2 = function (value, done) { + return { value: value, done: done }; +}; + +var toIndexedObject$1 = toIndexedObject$7; +var addToUnscopables = addToUnscopables$1; +var Iterators = iterators; +var InternalStateModule$2 = internalState; +var defineProperty$1 = objectDefineProperty.f; +var defineIterator$1 = iteratorDefine; +var createIterResultObject$1 = createIterResultObject$2; +var DESCRIPTORS = descriptors; + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState$2 = InternalStateModule$2.set; +var getInternalState$1 = InternalStateModule$2.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.es/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.es/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.es/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.es/ecma262/#sec-createarrayiterator +var es_array_iterator = defineIterator$1(Array, 'Array', function (iterated, kind) { + setInternalState$2(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject$1(iterated), // target + index: 0, // next index + kind: kind // kind + }); +// `%ArrayIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState$1(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return createIterResultObject$1(undefined, true); + } + switch (state.kind) { + case 'keys': return createIterResultObject$1(index, false); + case 'values': return createIterResultObject$1(target[index], false); + } return createIterResultObject$1([index, target[index]], false); +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.es/ecma262/#sec-createunmappedargumentsobject +// https://tc39.es/ecma262/#sec-createmappedargumentsobject +var values = Iterators.Arguments = Iterators.Array; + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + +// V8 ~ Chrome 45- bug +if (DESCRIPTORS && values.name !== 'values') try { + defineProperty$1(values, 'name', { value: 'values' }); +} catch (error) { /* empty */ } + +var classof$3 = classof$8; + +var $String = String; + +var toString$2 = function (argument) { + if (classof$3(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string'); + return $String(argument); +}; + +var uncurryThis$4 = functionUncurryThis; +var toIntegerOrInfinity = toIntegerOrInfinity$3; +var toString$1 = toString$2; +var requireObjectCoercible = requireObjectCoercible$3; + +var charAt$1 = uncurryThis$4(''.charAt); +var charCodeAt = uncurryThis$4(''.charCodeAt); +var stringSlice = uncurryThis$4(''.slice); + +var createMethod$1 = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = toString$1(requireObjectCoercible($this)); + var position = toIntegerOrInfinity(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = charCodeAt(S, position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt$1(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; +}; + +var stringMultibyte = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod$1(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod$1(true) +}; + +var charAt = stringMultibyte.charAt; +var toString = toString$2; +var InternalStateModule$1 = internalState; +var defineIterator = iteratorDefine; +var createIterResultObject = createIterResultObject$2; + +var STRING_ITERATOR = 'String Iterator'; +var setInternalState$1 = InternalStateModule$1.set; +var getInternalState = InternalStateModule$1.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-string.prototype-@@iterator +defineIterator(String, 'String', function (iterated) { + setInternalState$1(this, { + type: STRING_ITERATOR, + string: toString(iterated), + index: 0 + }); +// `%StringIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next +}, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return createIterResultObject(undefined, true); + point = charAt(string, index); + state.index += point.length; + return createIterResultObject(point, false); +}); + +var internalMetadata = {exports: {}}; + +var objectGetOwnPropertyNamesExternal = {}; + +var toPropertyKey = toPropertyKey$3; +var definePropertyModule = objectDefineProperty; +var createPropertyDescriptor = createPropertyDescriptor$4; + +var createProperty$1 = function (object, key, value) { + var propertyKey = toPropertyKey(key); + if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; +}; + +var toAbsoluteIndex = toAbsoluteIndex$2; +var lengthOfArrayLike$1 = lengthOfArrayLike$4; +var createProperty = createProperty$1; + +var $Array$1 = Array; +var max = Math.max; + +var arraySliceSimple = function (O, start, end) { + var length = lengthOfArrayLike$1(O); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + var result = $Array$1(max(fin - k, 0)); + var n = 0; + for (; k < fin; k++, n++) createProperty(result, n, O[k]); + result.length = n; + return result; +}; + +/* eslint-disable es/no-object-getownpropertynames -- safe */ +var classof$2 = classofRaw$2; +var toIndexedObject = toIndexedObject$7; +var $getOwnPropertyNames = objectGetOwnPropertyNames.f; +var arraySlice = arraySliceSimple; + +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function (it) { + try { + return $getOwnPropertyNames(it); + } catch (error) { + return arraySlice(windowNames); + } +}; + +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames(it) { + return windowNames && classof$2(it) === 'Window' + ? getWindowNames(it) + : $getOwnPropertyNames(toIndexedObject(it)); +}; + +// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it +var fails$4 = fails$j; + +var arrayBufferNonExtensible = fails$4(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } +}); + +var fails$3 = fails$j; +var isObject$5 = isObject$e; +var classof$1 = classofRaw$2; +var ARRAY_BUFFER_NON_EXTENSIBLE = arrayBufferNonExtensible; + +// eslint-disable-next-line es/no-object-isextensible -- safe +var $isExtensible = Object.isExtensible; +var FAILS_ON_PRIMITIVES$1 = fails$3(function () { $isExtensible(1); }); + +// `Object.isExtensible` method +// https://tc39.es/ecma262/#sec-object.isextensible +var objectIsExtensible = (FAILS_ON_PRIMITIVES$1 || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) { + if (!isObject$5(it)) return false; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof$1(it) === 'ArrayBuffer') return false; + return $isExtensible ? $isExtensible(it) : true; +} : $isExtensible; + +var fails$2 = fails$j; + +var freezing = !fails$2(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); +}); + +var $$2 = _export; +var uncurryThis$3 = functionUncurryThis; +var hiddenKeys = hiddenKeys$5; +var isObject$4 = isObject$e; +var hasOwn$1 = hasOwnProperty_1; +var defineProperty = objectDefineProperty.f; +var getOwnPropertyNamesModule = objectGetOwnPropertyNames; +var getOwnPropertyNamesExternalModule = objectGetOwnPropertyNamesExternal; +var isExtensible = objectIsExtensible; +var uid = uid$3; +var FREEZING = freezing; + +var REQUIRED = false; +var METADATA = uid('meta'); +var id$1 = 0; + +var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + id$1++, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject$4(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData$1 = function (it, create) { + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn$1(it, METADATA)) setMetadata(it); + return it; +}; + +var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis$3([].splice); + var test = {}; + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $$2({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } +}; + +var meta = internalMetadata.exports = { + enable: enable, + fastKey: fastKey, + getWeakData: getWeakData$1, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; + +var internalMetadataExports = internalMetadata.exports; + +var isCallable$1 = isCallable$m; +var isObject$3 = isObject$e; +var setPrototypeOf = objectSetPrototypeOf; + +// makes subclassing work correct for wrapped built-ins +var inheritIfRequired$1 = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable$1(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject$3(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; +}; + +var $$1 = _export; +var global$3 = global$k; +var uncurryThis$2 = functionUncurryThis; +var isForced = isForced_1; +var defineBuiltIn$1 = defineBuiltIn$8; +var InternalMetadataModule = internalMetadataExports; +var iterate$1 = iterate$4; +var anInstance$1 = anInstance$3; +var isCallable = isCallable$m; +var isNullOrUndefined$1 = isNullOrUndefined$6; +var isObject$2 = isObject$e; +var fails$1 = fails$j; +var checkCorrectnessOfIteration = checkCorrectnessOfIteration$2; +var setToStringTag$1 = setToStringTag$5; +var inheritIfRequired = inheritIfRequired$1; + +var collection$1 = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global$3[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis$2(NativePrototype[KEY]); + defineBuiltIn$1(NativePrototype, KEY, + KEY === 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY === 'delete' ? function (key) { + return IS_WEAK && !isObject$2(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'get' ? function get(key) { + return IS_WEAK && !isObject$2(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'has' ? function has(key) { + return IS_WEAK && !isObject$2(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails$1(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails$1(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails$1(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance$1(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (!isNullOrUndefined$1(iterable)) iterate$1(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $$1({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported); + + setToStringTag$1(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + +var defineBuiltIn = defineBuiltIn$8; + +var defineBuiltIns$1 = function (target, src, options) { + for (var key in src) defineBuiltIn(target, key, src[key], options); + return target; +}; + +var classof = classofRaw$2; + +// `IsArray` abstract operation +// https://tc39.es/ecma262/#sec-isarray +// eslint-disable-next-line es/no-array-isarray -- safe +var isArray$1 = Array.isArray || function isArray(argument) { + return classof(argument) === 'Array'; +}; + +var isArray = isArray$1; +var isConstructor = isConstructor$2; +var isObject$1 = isObject$e; +var wellKnownSymbol$1 = wellKnownSymbol$f; + +var SPECIES = wellKnownSymbol$1('species'); +var $Array = Array; + +// a part of `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +var arraySpeciesConstructor$1 = function (originalArray) { + var C; + if (isArray(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined; + else if (isObject$1(C)) { + C = C[SPECIES]; + if (C === null) C = undefined; + } + } return C === undefined ? $Array : C; +}; + +var arraySpeciesConstructor = arraySpeciesConstructor$1; + +// `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +var arraySpeciesCreate$1 = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); +}; + +var bind = functionBindContext; +var uncurryThis$1 = functionUncurryThis; +var IndexedObject = indexedObject; +var toObject$1 = toObject$5; +var lengthOfArrayLike = lengthOfArrayLike$4; +var arraySpeciesCreate = arraySpeciesCreate$1; + +var push = uncurryThis$1([].push); + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation +var createMethod = function (TYPE) { + var IS_MAP = TYPE === 1; + var IS_FILTER = TYPE === 2; + var IS_SOME = TYPE === 3; + var IS_EVERY = TYPE === 4; + var IS_FIND_INDEX = TYPE === 6; + var IS_FILTER_REJECT = TYPE === 7; + var NO_HOLES = TYPE === 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject$1($this); + var self = IndexedObject(O); + var length = lengthOfArrayLike(self); + var boundFunction = bind(callbackfn, that); + var index = 0; + var create = specificCreate || arraySpeciesCreate; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push(target, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +var arrayIteration = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod(7) +}; + +var uncurryThis = functionUncurryThis; +var defineBuiltIns = defineBuiltIns$1; +var getWeakData = internalMetadataExports.getWeakData; +var anInstance = anInstance$3; +var anObject = anObject$b; +var isNullOrUndefined = isNullOrUndefined$6; +var isObject = isObject$e; +var iterate = iterate$4; +var ArrayIterationModule = arrayIteration; +var hasOwn = hasOwnProperty_1; +var InternalStateModule = internalState; + +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; +var find = ArrayIterationModule.find; +var findIndex = ArrayIterationModule.findIndex; +var splice = uncurryThis([].splice); +var id = 0; + +// fallback for uncaught frozen keys +var uncaughtFrozenStore = function (state) { + return state.frozen || (state.frozen = new UncaughtFrozenStore()); +}; + +var UncaughtFrozenStore = function () { + this.entries = []; +}; + +var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); +}; + +UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) splice(this.entries, index, 1); + return !!~index; + } +}; + +var collectionWeak$1 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + defineBuiltIns(Prototype, { + // `{ WeakMap, WeakSet }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.delete + // https://tc39.es/ecma262/#sec-weakset.prototype.delete + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && hasOwn(data, state.id) && delete data[state.id]; + }, + // `{ WeakMap, WeakSet }.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.has + // https://tc39.es/ecma262/#sec-weakset.prototype.has + has: function has(key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && hasOwn(data, state.id); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `WeakMap.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.get + get: function get(key) { + var state = getInternalState(this); + if (isObject(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // `WeakMap.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.set + set: function set(key, value) { + return define(this, key, value); + } + } : { + // `WeakSet.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-weakset.prototype.add + add: function add(value) { + return define(this, value, true); + } + }); + + return Constructor; + } +}; + +var collection = collection$1; +var collectionWeak = collectionWeak$1; + +// `WeakSet` constructor +// https://tc39.es/ecma262/#sec-weakset-constructor +collection('WeakSet', function (init) { + return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionWeak); + +// iterable DOM collections +// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods +var domIterables = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + +// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList` +var documentCreateElement = documentCreateElement$2; + +var classList = documentCreateElement('span').classList; +var DOMTokenListPrototype$2 = classList && classList.constructor && classList.constructor.prototype; + +var domTokenListPrototype = DOMTokenListPrototype$2 === Object.prototype ? undefined : DOMTokenListPrototype$2; + +var global$2 = global$k; +var DOMIterables$1 = domIterables; +var DOMTokenListPrototype$1 = domTokenListPrototype; +var ArrayIteratorMethods = es_array_iterator; +var createNonEnumerableProperty$1 = createNonEnumerableProperty$5; +var setToStringTag = setToStringTag$5; +var wellKnownSymbol = wellKnownSymbol$f; + +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayValues = ArrayIteratorMethods.values; + +var handlePrototype$1 = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty$1(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + setToStringTag(CollectionPrototype, COLLECTION_NAME, true); + if (DOMIterables$1[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty$1(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } +}; + +for (var COLLECTION_NAME$1 in DOMIterables$1) { + handlePrototype$1(global$2[COLLECTION_NAME$1] && global$2[COLLECTION_NAME$1].prototype, COLLECTION_NAME$1); +} + +handlePrototype$1(DOMTokenListPrototype$1, 'DOMTokenList'); + +var $forEach = arrayIteration.forEach; +var arrayMethodIsStrict = arrayMethodIsStrict$2; + +var STRICT_METHOD = arrayMethodIsStrict('forEach'); + +// `Array.prototype.forEach` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.foreach +var arrayForEach = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); +// eslint-disable-next-line es/no-array-prototype-foreach -- safe +} : [].forEach; + +var global$1 = global$k; +var DOMIterables = domIterables; +var DOMTokenListPrototype = domTokenListPrototype; +var forEach = arrayForEach; +var createNonEnumerableProperty = createNonEnumerableProperty$5; + +var handlePrototype = function (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { + createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach); + } catch (error) { + CollectionPrototype.forEach = forEach; + } +}; + +for (var COLLECTION_NAME in DOMIterables) { + if (DOMIterables[COLLECTION_NAME]) { + handlePrototype(global$1[COLLECTION_NAME] && global$1[COLLECTION_NAME].prototype); + } +} + +handlePrototype(DOMTokenListPrototype); + +var $ = _export; +var toObject = toObject$5; +var nativeKeys = objectKeys$2; +var fails = fails$j; + +var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); }); + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { + keys: function keys(it) { + return nativeKeys(toObject(it)); + } +}); + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise */ + + +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +var ScrollDirection; +(function (ScrollDirection) { + ScrollDirection[ScrollDirection["SCROLL_NONE"] = 0] = "SCROLL_NONE"; + ScrollDirection[ScrollDirection["SCROLL_BACKWARD"] = 1] = "SCROLL_BACKWARD"; + ScrollDirection[ScrollDirection["SCROLL_FORWARD"] = 2] = "SCROLL_FORWARD"; +})(ScrollDirection || (ScrollDirection = {})); +var Position; +(function (Position) { + Position[Position["TOP"] = 0] = "TOP"; + Position[Position["RIGHT"] = 1] = "RIGHT"; + Position[Position["BOTTOM"] = 2] = "BOTTOM"; + Position[Position["LEFT"] = 3] = "LEFT"; +})(Position || (Position = {})); + +function isHorizontal(position) { + return position === 'left' || position === 'right'; +} +function isVertical(position) { + return position === 'top' || position === 'bottom'; +} +function horizontalPadding(padding) { + return padding[Position.LEFT] + padding[Position.RIGHT]; +} +function verticalPadding(padding) { + return padding[Position.TOP] + padding[Position.BOTTOM]; +} + +var _CalendarLabel_instances, _CalendarLabel_buildComputedOptions, _CalendarLabel_computeDimensions, _CalendarLabel_setRectAttr, _CalendarLabel_setTextAttr, _CalendarLabel_getTextXOffset, _CalendarLabel_getX, _CalendarLabel_getY; +var DEFAULT_SELECTOR = '.ch-plugin-calendar-label'; +var defaultOptions = { + enabled: true, + dimensions: { + width: 0, + height: 0 + }, + position: 'left', + text: function text() { + return []; + }, + padding: [0, 0, 0, 0] +}; +var CalendarLabel = /*#__PURE__*/function () { + function CalendarLabel(calendar) { + _classCallCheck(this, CalendarLabel); + var _a, _b; + _CalendarLabel_instances.add(this); + this.name = 'CalendarLabel'; + var subDomain = (_b = (_a = calendar === null || calendar === void 0 ? void 0 : calendar.options) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.subDomain; + this.calendar = calendar; + this.root = null; + this.shown = false; + this.options = defaultOptions; + this.computedOptions = { + radius: subDomain === null || subDomain === void 0 ? void 0 : subDomain.radius, + width: subDomain === null || subDomain === void 0 ? void 0 : subDomain.width, + height: subDomain === null || subDomain === void 0 ? void 0 : subDomain.height, + gutter: subDomain === null || subDomain === void 0 ? void 0 : subDomain.gutter, + textAlign: 'start' + }; + } + _createClass(CalendarLabel, [{ + key: "setup", + value: function setup(pluginOptions) { + this.options = Object.assign(Object.assign({}, defaultOptions), pluginOptions); + } + }, { + key: "paint", + value: function paint() { + var enabled = this.options.enabled; + if (!enabled) { + return this.destroy(); + } + this.shown = true; + var calendarRoot = this.calendar.calendarPainter.root; + if (!this.root) { + this.root = calendarRoot.append('svg').attr('class', DEFAULT_SELECTOR.slice(1)).attr('data-key', this.options.key).attr('x', 0).attr('y', 0); + } + this.build(); + return Promise.resolve(); + } + }, { + key: "destroy", + value: function destroy() { + if (this.root !== null) { + this.root.remove(); + this.root = null; + } + return Promise.resolve(); + } + }, { + key: "build", + value: function build() { + var _this = this; + __classPrivateFieldGet(this, _CalendarLabel_instances, "m", _CalendarLabel_buildComputedOptions).call(this); + __classPrivateFieldGet(this, _CalendarLabel_instances, "m", _CalendarLabel_computeDimensions).call(this); + this.root.selectAll('g').data(this.options.text).join(function (enter) { + return enter.append('g').call(function (selection) { + return selection.append('rect').attr('class', "".concat(DEFAULT_SELECTOR.slice(1), "-bg")).attr('style', 'fill: transparent').call(function (s) { + return __classPrivateFieldGet(_this, _CalendarLabel_instances, "m", _CalendarLabel_setRectAttr).call(_this, s); + }); + }).call(function (selection) { + return selection.append('text').attr('class', "".concat(DEFAULT_SELECTOR.slice(1), "-text")).attr('dominant-baseline', 'central').attr('text-anchor', 'middle').attr('style', 'fill: currentColor; font-size: 10px').call(function (s) { + return __classPrivateFieldGet(_this, _CalendarLabel_instances, "m", _CalendarLabel_setTextAttr).call(_this, s); + }); + }); + }); + return Promise.resolve(); + } + }]); + return CalendarLabel; +}(); +_CalendarLabel_instances = new WeakSet(), _CalendarLabel_buildComputedOptions = function _CalendarLabel_buildComputedOptions() { + var _this2 = this; + Object.keys(this.computedOptions).forEach(function (key) { + if (typeof _this2.options[key] !== 'undefined') { + // @ts-ignore + _this2.computedOptions[key] = _this2.options[key]; + } + }); +}, _CalendarLabel_computeDimensions = function _CalendarLabel_computeDimensions() { + var _this$computedOptions = this.computedOptions, + width = _this$computedOptions.width, + height = _this$computedOptions.height, + gutter = _this$computedOptions.gutter; + var _this$options = this.options, + text = _this$options.text, + padding = _this$options.padding, + position = _this$options.position; + var labelsCount = text().length; + this.options.dimensions = { + width: width + horizontalPadding(padding), + height: height + verticalPadding(padding) + }; + if (isVertical(position)) { + this.options.dimensions.width += (width + gutter) * (labelsCount - 1); + } else { + this.options.dimensions.height += (height + gutter) * (labelsCount - 1); + } +}, _CalendarLabel_setRectAttr = function _CalendarLabel_setRectAttr(selection) { + var _this3 = this; + var _this$computedOptions2 = this.computedOptions, + width = _this$computedOptions2.width, + height = _this$computedOptions2.height, + radius = _this$computedOptions2.radius; + selection.attr('width', width).attr('height', height).attr('rx', radius && radius > 0 ? radius : null).attr('ry', radius && radius > 0 ? radius : null).attr('x', function (_d, i) { + return __classPrivateFieldGet(_this3, _CalendarLabel_instances, "m", _CalendarLabel_getX).call(_this3, i); + }).attr('y', function (_d, i) { + return __classPrivateFieldGet(_this3, _CalendarLabel_instances, "m", _CalendarLabel_getY).call(_this3, i); + }); +}, _CalendarLabel_setTextAttr = function _CalendarLabel_setTextAttr(selection) { + var _this4 = this; + var _this$computedOptions3 = this.computedOptions, + height = _this$computedOptions3.height, + textAlign = _this$computedOptions3.textAlign; + selection.attr('text-anchor', textAlign).attr('x', function (_d, i) { + return __classPrivateFieldGet(_this4, _CalendarLabel_instances, "m", _CalendarLabel_getTextXOffset).call(_this4) + __classPrivateFieldGet(_this4, _CalendarLabel_instances, "m", _CalendarLabel_getX).call(_this4, i); + }).attr('y', function (_d, i) { + return __classPrivateFieldGet(_this4, _CalendarLabel_instances, "m", _CalendarLabel_getY).call(_this4, i) + height / 2; + }).text(function (data) { + return data; + }); +}, _CalendarLabel_getTextXOffset = function _CalendarLabel_getTextXOffset() { + var _this$computedOptions4 = this.computedOptions, + width = _this$computedOptions4.width, + textAlign = _this$computedOptions4.textAlign; + switch (textAlign) { + case 'start': + return 0; + case 'middle': + return width / 2; + case 'end': + return width; + default: + return 0; + } +}, _CalendarLabel_getX = function _CalendarLabel_getX(index) { + var _this$options2 = this.options, + position = _this$options2.position, + padding = _this$options2.padding; + var _this$computedOptions5 = this.computedOptions, + width = _this$computedOptions5.width, + gutter = _this$computedOptions5.gutter; + if (isHorizontal(position)) { + return padding[Position.LEFT]; + } + return padding[Position.LEFT] + (width + gutter) * index; +}, _CalendarLabel_getY = function _CalendarLabel_getY(index) { + var _this$options3 = this.options, + position = _this$options3.position, + padding = _this$options3.padding; + var _this$computedOptions6 = this.computedOptions, + height = _this$computedOptions6.height, + gutter = _this$computedOptions6.gutter; + if (isVertical(position)) { + return padding[Position.TOP]; + } + return padding[Position.TOP] + (height + gutter) * index; +}; + +export { CalendarLabel as default }; diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.js b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.js new file mode 100644 index 0000000..a74e434 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.js @@ -0,0 +1,3801 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : + typeof define === 'function' && define.amd ? define(factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.CalendarLabel = factory()); +})(this, (function () { 'use strict'; + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; + } + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); + } + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); + } + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + var fails$j = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } + }; + + var fails$i = fails$j; + + // Detect IE8's incomplete defineProperty implementation + var descriptors = !fails$i(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; + }); + + var fails$h = fails$j; + + var functionBindNative = !fails$h(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); + }); + + var NATIVE_BIND$3 = functionBindNative; + + var FunctionPrototype$3 = Function.prototype; + var call$e = FunctionPrototype$3.call; + var uncurryThisWithBind = NATIVE_BIND$3 && FunctionPrototype$3.bind.bind(call$e, call$e); + + var functionUncurryThis = NATIVE_BIND$3 ? uncurryThisWithBind : function (fn) { + return function () { + return call$e.apply(fn, arguments); + }; + }; + + // we can't use just `it == null` since of `document.all` special case + // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec + var isNullOrUndefined$6 = function (it) { + return it === null || it === undefined; + }; + + var isNullOrUndefined$5 = isNullOrUndefined$6; + + var $TypeError$c = TypeError; + + // `RequireObjectCoercible` abstract operation + // https://tc39.es/ecma262/#sec-requireobjectcoercible + var requireObjectCoercible$3 = function (it) { + if (isNullOrUndefined$5(it)) throw new $TypeError$c("Can't call method on " + it); + return it; + }; + + var requireObjectCoercible$2 = requireObjectCoercible$3; + + var $Object$4 = Object; + + // `ToObject` abstract operation + // https://tc39.es/ecma262/#sec-toobject + var toObject$5 = function (argument) { + return $Object$4(requireObjectCoercible$2(argument)); + }; + + var uncurryThis$l = functionUncurryThis; + var toObject$4 = toObject$5; + + var hasOwnProperty = uncurryThis$l({}.hasOwnProperty); + + // `HasOwnProperty` abstract operation + // https://tc39.es/ecma262/#sec-hasownproperty + // eslint-disable-next-line es/no-object-hasown -- safe + var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject$4(it), key); + }; + + var DESCRIPTORS$b = descriptors; + var hasOwn$b = hasOwnProperty_1; + + var FunctionPrototype$2 = Function.prototype; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getDescriptor = DESCRIPTORS$b && Object.getOwnPropertyDescriptor; + + var EXISTS$1 = hasOwn$b(FunctionPrototype$2, 'name'); + // additional protection from minified / mangled / dropped function names + var PROPER = EXISTS$1 && (function something() { /* empty */ }).name === 'something'; + var CONFIGURABLE$1 = EXISTS$1 && (!DESCRIPTORS$b || (DESCRIPTORS$b && getDescriptor(FunctionPrototype$2, 'name').configurable)); + + var functionName = { + EXISTS: EXISTS$1, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE$1 + }; + + var makeBuiltIn$3 = {exports: {}}; + + var documentAll$2 = typeof document == 'object' && document.all; + + // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot + // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing + var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined; + + var documentAll_1 = { + all: documentAll$2, + IS_HTMLDDA: IS_HTMLDDA + }; + + var $documentAll$1 = documentAll_1; + + var documentAll$1 = $documentAll$1.all; + + // `IsCallable` abstract operation + // https://tc39.es/ecma262/#sec-iscallable + var isCallable$m = $documentAll$1.IS_HTMLDDA ? function (argument) { + return typeof argument == 'function' || argument === documentAll$1; + } : function (argument) { + return typeof argument == 'function'; + }; + + var check = function (it) { + return it && it.Math === Math && it; + }; + + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global$k = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + + var global$j = global$k; + + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$7 = Object.defineProperty; + + var defineGlobalProperty$3 = function (key, value) { + try { + defineProperty$7(global$j, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$j[key] = value; + } return value; + }; + + var global$i = global$k; + var defineGlobalProperty$2 = defineGlobalProperty$3; + + var SHARED = '__core-js_shared__'; + var store$3 = global$i[SHARED] || defineGlobalProperty$2(SHARED, {}); + + var sharedStore = store$3; + + var uncurryThis$k = functionUncurryThis; + var isCallable$l = isCallable$m; + var store$2 = sharedStore; + + var functionToString$1 = uncurryThis$k(Function.toString); + + // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper + if (!isCallable$l(store$2.inspectSource)) { + store$2.inspectSource = function (it) { + return functionToString$1(it); + }; + } + + var inspectSource$3 = store$2.inspectSource; + + var global$h = global$k; + var isCallable$k = isCallable$m; + + var WeakMap$1 = global$h.WeakMap; + + var weakMapBasicDetection = isCallable$k(WeakMap$1) && /native code/.test(String(WeakMap$1)); + + var isCallable$j = isCallable$m; + var $documentAll = documentAll_1; + + var documentAll = $documentAll.all; + + var isObject$e = $documentAll.IS_HTMLDDA ? function (it) { + return typeof it == 'object' ? it !== null : isCallable$j(it) || it === documentAll; + } : function (it) { + return typeof it == 'object' ? it !== null : isCallable$j(it); + }; + + var objectDefineProperty = {}; + + var global$g = global$k; + var isObject$d = isObject$e; + + var document$3 = global$g.document; + // typeof document.createElement is 'object' in old IE + var EXISTS = isObject$d(document$3) && isObject$d(document$3.createElement); + + var documentCreateElement$2 = function (it) { + return EXISTS ? document$3.createElement(it) : {}; + }; + + var DESCRIPTORS$a = descriptors; + var fails$g = fails$j; + var createElement$1 = documentCreateElement$2; + + // Thanks to IE8 for its funny defineProperty + var ie8DomDefine = !DESCRIPTORS$a && !fails$g(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { + get: function () { return 7; } + }).a !== 7; + }); + + var DESCRIPTORS$9 = descriptors; + var fails$f = fails$j; + + // V8 ~ Chrome 36- + // https://bugs.chromium.org/p/v8/issues/detail?id=3334 + var v8PrototypeDefineBug = DESCRIPTORS$9 && fails$f(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; + }); + + var isObject$c = isObject$e; + + var $String$5 = String; + var $TypeError$b = TypeError; + + // `Assert: Type(argument) is Object` + var anObject$b = function (argument) { + if (isObject$c(argument)) return argument; + throw new $TypeError$b($String$5(argument) + ' is not an object'); + }; + + var NATIVE_BIND$2 = functionBindNative; + + var call$d = Function.prototype.call; + + var functionCall = NATIVE_BIND$2 ? call$d.bind(call$d) : function () { + return call$d.apply(call$d, arguments); + }; + + var global$f = global$k; + var isCallable$i = isCallable$m; + + var aFunction = function (argument) { + return isCallable$i(argument) ? argument : undefined; + }; + + var getBuiltIn$7 = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$f[namespace]) : global$f[namespace] && global$f[namespace][method]; + }; + + var uncurryThis$j = functionUncurryThis; + + var objectIsPrototypeOf = uncurryThis$j({}.isPrototypeOf); + + var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || ''; + + var global$e = global$k; + var userAgent$3 = engineUserAgent; + + var process$3 = global$e.process; + var Deno$1 = global$e.Deno; + var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version; + var v8 = versions && versions.v8; + var match, version; + + if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); + } + + // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` + // so check `userAgent` even if `.v8` exists, but 0 + if (!version && userAgent$3) { + match = userAgent$3.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$3.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } + } + + var engineV8Version = version; + + /* eslint-disable es/no-symbol -- required for testing */ + var V8_VERSION$1 = engineV8Version; + var fails$e = fails$j; + var global$d = global$k; + + var $String$4 = global$d.String; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing + var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$e(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String$4(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$1 && V8_VERSION$1 < 41; + }); + + /* eslint-disable es/no-symbol -- required for testing */ + var NATIVE_SYMBOL$1 = symbolConstructorDetection; + + var useSymbolAsUid = NATIVE_SYMBOL$1 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + + var getBuiltIn$6 = getBuiltIn$7; + var isCallable$h = isCallable$m; + var isPrototypeOf$2 = objectIsPrototypeOf; + var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + + var $Object$3 = Object; + + var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) { + return typeof it == 'symbol'; + } : function (it) { + var $Symbol = getBuiltIn$6('Symbol'); + return isCallable$h($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it)); + }; + + var $String$3 = String; + + var tryToString$4 = function (argument) { + try { + return $String$3(argument); + } catch (error) { + return 'Object'; + } + }; + + var isCallable$g = isCallable$m; + var tryToString$3 = tryToString$4; + + var $TypeError$a = TypeError; + + // `Assert: IsCallable(argument) is true` + var aCallable$8 = function (argument) { + if (isCallable$g(argument)) return argument; + throw new $TypeError$a(tryToString$3(argument) + ' is not a function'); + }; + + var aCallable$7 = aCallable$8; + var isNullOrUndefined$4 = isNullOrUndefined$6; + + // `GetMethod` abstract operation + // https://tc39.es/ecma262/#sec-getmethod + var getMethod$3 = function (V, P) { + var func = V[P]; + return isNullOrUndefined$4(func) ? undefined : aCallable$7(func); + }; + + var call$c = functionCall; + var isCallable$f = isCallable$m; + var isObject$b = isObject$e; + + var $TypeError$9 = TypeError; + + // `OrdinaryToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-ordinarytoprimitive + var ordinaryToPrimitive$1 = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable$f(fn = input.toString) && !isObject$b(val = call$c(fn, input))) return val; + if (isCallable$f(fn = input.valueOf) && !isObject$b(val = call$c(fn, input))) return val; + if (pref !== 'string' && isCallable$f(fn = input.toString) && !isObject$b(val = call$c(fn, input))) return val; + throw new $TypeError$9("Can't convert object to primitive value"); + }; + + var shared$3 = {exports: {}}; + + var store$1 = sharedStore; + + (shared$3.exports = function (key, value) { + return store$1[key] || (store$1[key] = value !== undefined ? value : {}); + })('versions', []).push({ + version: '3.34.0', + mode: 'global', + copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE', + source: 'https://github.com/zloirock/core-js' + }); + + var sharedExports = shared$3.exports; + + var uncurryThis$i = functionUncurryThis; + + var id$2 = 0; + var postfix = Math.random(); + var toString$5 = uncurryThis$i(1.0.toString); + + var uid$3 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$5(++id$2 + postfix, 36); + }; + + var global$c = global$k; + var shared$2 = sharedExports; + var hasOwn$a = hasOwnProperty_1; + var uid$2 = uid$3; + var NATIVE_SYMBOL = symbolConstructorDetection; + var USE_SYMBOL_AS_UID = useSymbolAsUid; + + var Symbol$1 = global$c.Symbol; + var WellKnownSymbolsStore = shared$2('wks'); + var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$2; + + var wellKnownSymbol$f = function (name) { + if (!hasOwn$a(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$a(Symbol$1, name) + ? Symbol$1[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; + }; + + var call$b = functionCall; + var isObject$a = isObject$e; + var isSymbol$1 = isSymbol$2; + var getMethod$2 = getMethod$3; + var ordinaryToPrimitive = ordinaryToPrimitive$1; + var wellKnownSymbol$e = wellKnownSymbol$f; + + var $TypeError$8 = TypeError; + var TO_PRIMITIVE = wellKnownSymbol$e('toPrimitive'); + + // `ToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-toprimitive + var toPrimitive$1 = function (input, pref) { + if (!isObject$a(input) || isSymbol$1(input)) return input; + var exoticToPrim = getMethod$2(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$b(exoticToPrim, input, pref); + if (!isObject$a(result) || isSymbol$1(result)) return result; + throw new $TypeError$8("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); + }; + + var toPrimitive = toPrimitive$1; + var isSymbol = isSymbol$2; + + // `ToPropertyKey` abstract operation + // https://tc39.es/ecma262/#sec-topropertykey + var toPropertyKey$3 = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; + }; + + var DESCRIPTORS$8 = descriptors; + var IE8_DOM_DEFINE$1 = ie8DomDefine; + var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug; + var anObject$a = anObject$b; + var toPropertyKey$2 = toPropertyKey$3; + + var $TypeError$7 = TypeError; + // eslint-disable-next-line es/no-object-defineproperty -- safe + var $defineProperty = Object.defineProperty; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; + var ENUMERABLE = 'enumerable'; + var CONFIGURABLE = 'configurable'; + var WRITABLE = 'writable'; + + // `Object.defineProperty` method + // https://tc39.es/ecma262/#sec-object.defineproperty + objectDefineProperty.f = DESCRIPTORS$8 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) { + anObject$a(O); + P = toPropertyKey$2(P); + anObject$a(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor$1(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); + } : $defineProperty : function defineProperty(O, P, Attributes) { + anObject$a(O); + P = toPropertyKey$2(P); + anObject$a(Attributes); + if (IE8_DOM_DEFINE$1) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$7('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; + }; + + var createPropertyDescriptor$4 = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; + }; + + var DESCRIPTORS$7 = descriptors; + var definePropertyModule$4 = objectDefineProperty; + var createPropertyDescriptor$3 = createPropertyDescriptor$4; + + var createNonEnumerableProperty$5 = DESCRIPTORS$7 ? function (object, key, value) { + return definePropertyModule$4.f(object, key, createPropertyDescriptor$3(1, value)); + } : function (object, key, value) { + object[key] = value; + return object; + }; + + var shared$1 = sharedExports; + var uid$1 = uid$3; + + var keys = shared$1('keys'); + + var sharedKey$3 = function (key) { + return keys[key] || (keys[key] = uid$1(key)); + }; + + var hiddenKeys$5 = {}; + + var NATIVE_WEAK_MAP = weakMapBasicDetection; + var global$b = global$k; + var isObject$9 = isObject$e; + var createNonEnumerableProperty$4 = createNonEnumerableProperty$5; + var hasOwn$9 = hasOwnProperty_1; + var shared = sharedStore; + var sharedKey$2 = sharedKey$3; + var hiddenKeys$4 = hiddenKeys$5; + + var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; + var TypeError$2 = global$b.TypeError; + var WeakMap = global$b.WeakMap; + var set$1, get, has; + + var enforce = function (it) { + return has(it) ? get(it) : set$1(it, {}); + }; + + var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject$9(it) || (state = get(it)).type !== TYPE) { + throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; + }; + + if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set$1 = function (it, metadata) { + if (store.has(it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get = function (it) { + return store.get(it) || {}; + }; + has = function (it) { + return store.has(it); + }; + } else { + var STATE = sharedKey$2('state'); + hiddenKeys$4[STATE] = true; + set$1 = function (it, metadata) { + if (hasOwn$9(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty$4(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn$9(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn$9(it, STATE); + }; + } + + var internalState = { + set: set$1, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor + }; + + var uncurryThis$h = functionUncurryThis; + var fails$d = fails$j; + var isCallable$e = isCallable$m; + var hasOwn$8 = hasOwnProperty_1; + var DESCRIPTORS$6 = descriptors; + var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE; + var inspectSource$2 = inspectSource$3; + var InternalStateModule$4 = internalState; + + var enforceInternalState = InternalStateModule$4.enforce; + var getInternalState$2 = InternalStateModule$4.get; + var $String$2 = String; + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$6 = Object.defineProperty; + var stringSlice$2 = uncurryThis$h(''.slice); + var replace = uncurryThis$h(''.replace); + var join = uncurryThis$h([].join); + + var CONFIGURABLE_LENGTH = DESCRIPTORS$6 && !fails$d(function () { + return defineProperty$6(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; + }); + + var TEMPLATE = String(String).split('String'); + + var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) { + if (stringSlice$2($String$2(name), 0, 7) === 'Symbol(') { + name = '[' + replace($String$2(name), /^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn$8(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) { + if (DESCRIPTORS$6) defineProperty$6(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn$8(options, 'arity') && value.length !== options.arity) { + defineProperty$6(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn$8(options, 'constructor') && options.constructor) { + if (DESCRIPTORS$6) defineProperty$6(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn$8(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; + }; + + // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative + // eslint-disable-next-line no-extend-native -- required + Function.prototype.toString = makeBuiltIn$2(function toString() { + return isCallable$e(this) && getInternalState$2(this).source || inspectSource$2(this); + }, 'toString'); + + var makeBuiltInExports = makeBuiltIn$3.exports; + + var makeBuiltIn$1 = makeBuiltInExports; + var defineProperty$5 = objectDefineProperty; + + var defineBuiltInAccessor$2 = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn$1(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn$1(descriptor.set, name, { setter: true }); + return defineProperty$5.f(target, name, descriptor); + }; + + var DESCRIPTORS$5 = descriptors; + var FUNCTION_NAME_EXISTS = functionName.EXISTS; + var uncurryThis$g = functionUncurryThis; + var defineBuiltInAccessor$1 = defineBuiltInAccessor$2; + + var FunctionPrototype$1 = Function.prototype; + var functionToString = uncurryThis$g(FunctionPrototype$1.toString); + var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; + var regExpExec = uncurryThis$g(nameRE.exec); + var NAME = 'name'; + + // Function instances `.name` property + // https://tc39.es/ecma262/#sec-function-instances-name + if (DESCRIPTORS$5 && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor$1(FunctionPrototype$1, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); + } + + var objectGetOwnPropertyDescriptor = {}; + + var objectPropertyIsEnumerable = {}; + + var $propertyIsEnumerable = {}.propertyIsEnumerable; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor; + + // Nashorn ~ JDK8 bug + var NASHORN_BUG = getOwnPropertyDescriptor$2 && !$propertyIsEnumerable.call({ 1: 2 }, 1); + + // `Object.prototype.propertyIsEnumerable` method implementation + // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable + objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor$2(this, V); + return !!descriptor && descriptor.enumerable; + } : $propertyIsEnumerable; + + var uncurryThis$f = functionUncurryThis; + + var toString$4 = uncurryThis$f({}.toString); + var stringSlice$1 = uncurryThis$f(''.slice); + + var classofRaw$2 = function (it) { + return stringSlice$1(toString$4(it), 8, -1); + }; + + var uncurryThis$e = functionUncurryThis; + var fails$c = fails$j; + var classof$9 = classofRaw$2; + + var $Object$2 = Object; + var split = uncurryThis$e(''.split); + + // fallback for non-array-like ES3 and non-enumerable old V8 strings + var indexedObject = fails$c(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object$2('z').propertyIsEnumerable(0); + }) ? function (it) { + return classof$9(it) === 'String' ? split(it, '') : $Object$2(it); + } : $Object$2; + + // toObject with fallback for non-array-like ES3 strings + var IndexedObject$3 = indexedObject; + var requireObjectCoercible$1 = requireObjectCoercible$3; + + var toIndexedObject$7 = function (it) { + return IndexedObject$3(requireObjectCoercible$1(it)); + }; + + var DESCRIPTORS$4 = descriptors; + var call$a = functionCall; + var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; + var createPropertyDescriptor$2 = createPropertyDescriptor$4; + var toIndexedObject$6 = toIndexedObject$7; + var toPropertyKey$1 = toPropertyKey$3; + var hasOwn$7 = hasOwnProperty_1; + var IE8_DOM_DEFINE = ie8DomDefine; + + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + + // `Object.getOwnPropertyDescriptor` method + // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor + objectGetOwnPropertyDescriptor.f = DESCRIPTORS$4 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$6(O); + P = toPropertyKey$1(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn$7(O, P)) return createPropertyDescriptor$2(!call$a(propertyIsEnumerableModule$1.f, O, P), O[P]); + }; + + var isCallable$d = isCallable$m; + var definePropertyModule$3 = objectDefineProperty; + var makeBuiltIn = makeBuiltInExports; + var defineGlobalProperty$1 = defineGlobalProperty$3; + + var defineBuiltIn$8 = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable$d(value)) makeBuiltIn(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty$1(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule$3.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; + }; + + var objectGetOwnPropertyNames = {}; + + var ceil = Math.ceil; + var floor = Math.floor; + + // `Math.trunc` method + // https://tc39.es/ecma262/#sec-math.trunc + // eslint-disable-next-line es/no-math-trunc -- safe + var mathTrunc = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor : ceil)(n); + }; + + var trunc = mathTrunc; + + // `ToIntegerOrInfinity` abstract operation + // https://tc39.es/ecma262/#sec-tointegerorinfinity + var toIntegerOrInfinity$3 = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); + }; + + var toIntegerOrInfinity$2 = toIntegerOrInfinity$3; + + var max$1 = Math.max; + var min$1 = Math.min; + + // Helper for a popular repeating case of the spec: + // Let integer be ? ToInteger(index). + // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). + var toAbsoluteIndex$2 = function (index, length) { + var integer = toIntegerOrInfinity$2(index); + return integer < 0 ? max$1(integer + length, 0) : min$1(integer, length); + }; + + var toIntegerOrInfinity$1 = toIntegerOrInfinity$3; + + var min = Math.min; + + // `ToLength` abstract operation + // https://tc39.es/ecma262/#sec-tolength + var toLength$1 = function (argument) { + return argument > 0 ? min(toIntegerOrInfinity$1(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 + }; + + var toLength = toLength$1; + + // `LengthOfArrayLike` abstract operation + // https://tc39.es/ecma262/#sec-lengthofarraylike + var lengthOfArrayLike$4 = function (obj) { + return toLength(obj.length); + }; + + var toIndexedObject$5 = toIndexedObject$7; + var toAbsoluteIndex$1 = toAbsoluteIndex$2; + var lengthOfArrayLike$3 = lengthOfArrayLike$4; + + // `Array.prototype.{ indexOf, includes }` methods implementation + var createMethod$2 = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject$5($this); + var length = lengthOfArrayLike$3(O); + var index = toAbsoluteIndex$1(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; + }; + + var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod$2(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod$2(false) + }; + + var uncurryThis$d = functionUncurryThis; + var hasOwn$6 = hasOwnProperty_1; + var toIndexedObject$4 = toIndexedObject$7; + var indexOf = arrayIncludes.indexOf; + var hiddenKeys$3 = hiddenKeys$5; + + var push$1 = uncurryThis$d([].push); + + var objectKeysInternal = function (object, names) { + var O = toIndexedObject$4(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn$6(hiddenKeys$3, key) && hasOwn$6(O, key) && push$1(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn$6(O, key = names[i++])) { + ~indexOf(result, key) || push$1(result, key); + } + return result; + }; + + // IE8- don't enum bug keys + var enumBugKeys$3 = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' + ]; + + var internalObjectKeys$1 = objectKeysInternal; + var enumBugKeys$2 = enumBugKeys$3; + + var hiddenKeys$2 = enumBugKeys$2.concat('length', 'prototype'); + + // `Object.getOwnPropertyNames` method + // https://tc39.es/ecma262/#sec-object.getownpropertynames + // eslint-disable-next-line es/no-object-getownpropertynames -- safe + objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys$2); + }; + + var objectGetOwnPropertySymbols = {}; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe + objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; + + var getBuiltIn$5 = getBuiltIn$7; + var uncurryThis$c = functionUncurryThis; + var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames; + var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; + var anObject$9 = anObject$b; + + var concat$1 = uncurryThis$c([].concat); + + // all object keys, includes non-enumerable and symbols + var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule$1.f(anObject$9(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f; + return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys; + }; + + var hasOwn$5 = hasOwnProperty_1; + var ownKeys = ownKeys$1; + var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; + var definePropertyModule$2 = objectDefineProperty; + + var copyConstructorProperties$1 = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule$2.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn$5(target, key) && !(exceptions && hasOwn$5(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } + }; + + var fails$b = fails$j; + var isCallable$c = isCallable$m; + + var replacement = /#|\.prototype\./; + + var isForced$3 = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable$c(detection) ? fails$b(detection) + : !!detection; + }; + + var normalize = isForced$3.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); + }; + + var data = isForced$3.data = {}; + var NATIVE = isForced$3.NATIVE = 'N'; + var POLYFILL = isForced$3.POLYFILL = 'P'; + + var isForced_1 = isForced$3; + + var global$a = global$k; + var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; + var createNonEnumerableProperty$3 = createNonEnumerableProperty$5; + var defineBuiltIn$7 = defineBuiltIn$8; + var defineGlobalProperty = defineGlobalProperty$3; + var copyConstructorProperties = copyConstructorProperties$1; + var isForced$2 = isForced_1; + + /* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key + */ + var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global$a; + } else if (STATIC) { + target = global$a[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = (global$a[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor$1(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced$2(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty$3(sourceProperty, 'sham', true); + } + defineBuiltIn$7(target, key, sourceProperty, options); + } + }; + + var internalObjectKeys = objectKeysInternal; + var enumBugKeys$1 = enumBugKeys$3; + + // `Object.keys` method + // https://tc39.es/ecma262/#sec-object.keys + // eslint-disable-next-line es/no-object-keys -- safe + var objectKeys$2 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys$1); + }; + + var DESCRIPTORS$3 = descriptors; + var uncurryThis$b = functionUncurryThis; + var call$9 = functionCall; + var fails$a = fails$j; + var objectKeys$1 = objectKeys$2; + var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; + var propertyIsEnumerableModule = objectPropertyIsEnumerable; + var toObject$3 = toObject$5; + var IndexedObject$2 = indexedObject; + + // eslint-disable-next-line es/no-object-assign -- safe + var $assign = Object.assign; + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + var defineProperty$4 = Object.defineProperty; + var concat = uncurryThis$b([].concat); + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + var objectAssign = !$assign || fails$a(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$3 && $assign({ b: 1 }, $assign(defineProperty$4({}, 'a', { + enumerable: true, + get: function () { + defineProperty$4(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys$1($assign({}, B)).join('') !== alphabet; + }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject$3(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject$2(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$3 || call$9(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; + } : $assign; + + var $$b = _export; + var assign = objectAssign; + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + // eslint-disable-next-line es/no-object-assign -- required for testing + $$b({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign + }); + + var wellKnownSymbol$d = wellKnownSymbol$f; + + var TO_STRING_TAG$2 = wellKnownSymbol$d('toStringTag'); + var test = {}; + + test[TO_STRING_TAG$2] = 'z'; + + var toStringTagSupport = String(test) === '[object z]'; + + var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; + var isCallable$b = isCallable$m; + var classofRaw$1 = classofRaw$2; + var wellKnownSymbol$c = wellKnownSymbol$f; + + var TO_STRING_TAG$1 = wellKnownSymbol$c('toStringTag'); + var $Object$1 = Object; + + // ES3 wrong here + var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments'; + + // fallback for IE11 Script Access Denied error + var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } + }; + + // getting tag from ES6+ `Object.prototype.toString` + var classof$8 = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object$1(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw$1(O) + // ES3 arguments fallback + : (result = classofRaw$1(O)) === 'Object' && isCallable$b(O.callee) ? 'Arguments' : result; + }; + + var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; + var classof$7 = classof$8; + + // `Object.prototype.toString` method implementation + // https://tc39.es/ecma262/#sec-object.prototype.tostring + var objectToString = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$7(this) + ']'; + }; + + var TO_STRING_TAG_SUPPORT = toStringTagSupport; + var defineBuiltIn$6 = defineBuiltIn$8; + var toString$3 = objectToString; + + // `Object.prototype.toString` method + // https://tc39.es/ecma262/#sec-object.prototype.tostring + if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn$6(Object.prototype, 'toString', toString$3, { unsafe: true }); + } + + var global$9 = global$k; + var classof$6 = classofRaw$2; + + var engineIsNode = classof$6(global$9.process) === 'process'; + + var uncurryThis$a = functionUncurryThis; + var aCallable$6 = aCallable$8; + + var functionUncurryThisAccessor = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis$a(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } + }; + + var isCallable$a = isCallable$m; + + var $String$1 = String; + var $TypeError$6 = TypeError; + + var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$a(argument)) return argument; + throw new $TypeError$6("Can't set " + $String$1(argument) + ' as a prototype'); + }; + + /* eslint-disable no-proto -- safe */ + var uncurryThisAccessor = functionUncurryThisAccessor; + var anObject$8 = anObject$b; + var aPossiblePrototype = aPossiblePrototype$1; + + // `Object.setPrototypeOf` method + // https://tc39.es/ecma262/#sec-object.setprototypeof + // Works with __proto__ only. Old v8 can't work with null proto objects. + // eslint-disable-next-line es/no-object-setprototypeof -- safe + var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject$8(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; + }() : undefined); + + var defineProperty$3 = objectDefineProperty.f; + var hasOwn$4 = hasOwnProperty_1; + var wellKnownSymbol$b = wellKnownSymbol$f; + + var TO_STRING_TAG = wellKnownSymbol$b('toStringTag'); + + var setToStringTag$5 = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$4(target, TO_STRING_TAG)) { + defineProperty$3(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } + }; + + var getBuiltIn$4 = getBuiltIn$7; + var defineBuiltInAccessor = defineBuiltInAccessor$2; + var wellKnownSymbol$a = wellKnownSymbol$f; + var DESCRIPTORS$2 = descriptors; + + var SPECIES$3 = wellKnownSymbol$a('species'); + + var setSpecies$1 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME); + + if (DESCRIPTORS$2 && Constructor && !Constructor[SPECIES$3]) { + defineBuiltInAccessor(Constructor, SPECIES$3, { + configurable: true, + get: function () { return this; } + }); + } + }; + + var isPrototypeOf$1 = objectIsPrototypeOf; + + var $TypeError$5 = TypeError; + + var anInstance$3 = function (it, Prototype) { + if (isPrototypeOf$1(Prototype, it)) return it; + throw new $TypeError$5('Incorrect invocation'); + }; + + var uncurryThis$9 = functionUncurryThis; + var fails$9 = fails$j; + var isCallable$9 = isCallable$m; + var classof$5 = classof$8; + var getBuiltIn$3 = getBuiltIn$7; + var inspectSource$1 = inspectSource$3; + + var noop = function () { /* empty */ }; + var empty = []; + var construct = getBuiltIn$3('Reflect', 'construct'); + var constructorRegExp = /^\s*(?:class|function)\b/; + var exec = uncurryThis$9(constructorRegExp.exec); + var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + + var isConstructorModern = function isConstructor(argument) { + if (!isCallable$9(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } + }; + + var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$9(argument)) return false; + switch (classof$5(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } + }; + + isConstructorLegacy.sham = true; + + // `IsConstructor` abstract operation + // https://tc39.es/ecma262/#sec-isconstructor + var isConstructor$2 = !construct || fails$9(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; + }) ? isConstructorLegacy : isConstructorModern; + + var isConstructor$1 = isConstructor$2; + var tryToString$2 = tryToString$4; + + var $TypeError$4 = TypeError; + + // `Assert: IsConstructor(argument) is true` + var aConstructor$1 = function (argument) { + if (isConstructor$1(argument)) return argument; + throw new $TypeError$4(tryToString$2(argument) + ' is not a constructor'); + }; + + var anObject$7 = anObject$b; + var aConstructor = aConstructor$1; + var isNullOrUndefined$3 = isNullOrUndefined$6; + var wellKnownSymbol$9 = wellKnownSymbol$f; + + var SPECIES$2 = wellKnownSymbol$9('species'); + + // `SpeciesConstructor` abstract operation + // https://tc39.es/ecma262/#sec-speciesconstructor + var speciesConstructor$1 = function (O, defaultConstructor) { + var C = anObject$7(O).constructor; + var S; + return C === undefined || isNullOrUndefined$3(S = anObject$7(C)[SPECIES$2]) ? defaultConstructor : aConstructor(S); + }; + + var NATIVE_BIND$1 = functionBindNative; + + var FunctionPrototype = Function.prototype; + var apply$1 = FunctionPrototype.apply; + var call$8 = FunctionPrototype.call; + + // eslint-disable-next-line es/no-reflect -- safe + var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$8.bind(apply$1) : function () { + return call$8.apply(apply$1, arguments); + }); + + var classofRaw = classofRaw$2; + var uncurryThis$8 = functionUncurryThis; + + var functionUncurryThisClause = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis$8(fn); + }; + + var uncurryThis$7 = functionUncurryThisClause; + var aCallable$5 = aCallable$8; + var NATIVE_BIND = functionBindNative; + + var bind$5 = uncurryThis$7(uncurryThis$7.bind); + + // optional / simple context binding + var functionBindContext = function (fn, that) { + aCallable$5(fn); + return that === undefined ? fn : NATIVE_BIND ? bind$5(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; + }; + + var getBuiltIn$2 = getBuiltIn$7; + + var html$2 = getBuiltIn$2('document', 'documentElement'); + + var uncurryThis$6 = functionUncurryThis; + + var arraySlice$2 = uncurryThis$6([].slice); + + var $TypeError$3 = TypeError; + + var validateArgumentsLength$1 = function (passed, required) { + if (passed < required) throw new $TypeError$3('Not enough arguments'); + return passed; + }; + + var userAgent$2 = engineUserAgent; + + // eslint-disable-next-line redos/no-vulnerable -- safe + var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2); + + var global$8 = global$k; + var apply = functionApply; + var bind$4 = functionBindContext; + var isCallable$8 = isCallable$m; + var hasOwn$3 = hasOwnProperty_1; + var fails$8 = fails$j; + var html$1 = html$2; + var arraySlice$1 = arraySlice$2; + var createElement = documentCreateElement$2; + var validateArgumentsLength = validateArgumentsLength$1; + var IS_IOS$1 = engineIsIos; + var IS_NODE$3 = engineIsNode; + + var set = global$8.setImmediate; + var clear = global$8.clearImmediate; + var process$2 = global$8.process; + var Dispatch = global$8.Dispatch; + var Function$1 = global$8.Function; + var MessageChannel = global$8.MessageChannel; + var String$1 = global$8.String; + var counter = 0; + var queue$2 = {}; + var ONREADYSTATECHANGE = 'onreadystatechange'; + var $location, defer, channel, port; + + fails$8(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = global$8.location; + }); + + var run = function (id) { + if (hasOwn$3(queue$2, id)) { + var fn = queue$2[id]; + delete queue$2[id]; + fn(); + } + }; + + var runner = function (id) { + return function () { + run(id); + }; + }; + + var eventListener = function (event) { + run(event.data); + }; + + var globalPostMessageDefer = function (id) { + // old engines have not location.origin + global$8.postMessage(String$1(id), $location.protocol + '//' + $location.host); + }; + + // Node.js 0.9+ & IE10+ has setImmediate, otherwise: + if (!set || !clear) { + set = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable$8(handler) ? handler : Function$1(handler); + var args = arraySlice$1(arguments, 1); + queue$2[++counter] = function () { + apply(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue$2[id]; + }; + // Node.js 0.8- + if (IS_NODE$3) { + defer = function (id) { + process$2.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS$1) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind$4(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global$8.addEventListener && + isCallable$8(global$8.postMessage) && + !global$8.importScripts && + $location && $location.protocol !== 'file:' && + !fails$8(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + global$8.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html$1.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } + } + + var task$1 = { + set: set, + clear: clear + }; + + var Queue$2 = function () { + this.head = null; + this.tail = null; + }; + + Queue$2.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } + }; + + var queue$1 = Queue$2; + + var userAgent$1 = engineUserAgent; + + var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && typeof Pebble != 'undefined'; + + var userAgent = engineUserAgent; + + var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent); + + var global$7 = global$k; + var bind$3 = functionBindContext; + var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + var macrotask = task$1.set; + var Queue$1 = queue$1; + var IS_IOS = engineIsIos; + var IS_IOS_PEBBLE = engineIsIosPebble; + var IS_WEBOS_WEBKIT = engineIsWebosWebkit; + var IS_NODE$2 = engineIsNode; + + var MutationObserver = global$7.MutationObserver || global$7.WebKitMutationObserver; + var document$2 = global$7.document; + var process$1 = global$7.process; + var Promise$1 = global$7.Promise; + // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` + var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$7, 'queueMicrotask'); + var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; + var notify$1, toggle, node, promise, then; + + // modern engines have queueMicrotask method + if (!microtask$1) { + var queue = new Queue$1(); + + var flush = function () { + var parent, fn; + if (IS_NODE$2 && (parent = process$1.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify$1(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { + toggle = true; + node = document$2.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify$1 = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise$1.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise$1; + then = bind$3(promise.then, promise); + notify$1 = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE$2) { + notify$1 = function () { + process$1.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind$3(macrotask, global$7); + notify$1 = function () { + macrotask(flush); + }; + } + + microtask$1 = function (fn) { + if (!queue.head) notify$1(); + queue.add(fn); + }; + } + + var microtask_1 = microtask$1; + + var hostReportErrors$1 = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } + }; + + var perform$3 = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } + }; + + var global$6 = global$k; + + var promiseNativeConstructor = global$6.Promise; + + /* global Deno -- Deno case */ + var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object'; + + var IS_DENO$1 = engineIsDeno; + var IS_NODE$1 = engineIsNode; + + var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 + && typeof window == 'object' + && typeof document == 'object'; + + var global$5 = global$k; + var NativePromiseConstructor$3 = promiseNativeConstructor; + var isCallable$7 = isCallable$m; + var isForced$1 = isForced_1; + var inspectSource = inspectSource$3; + var wellKnownSymbol$8 = wellKnownSymbol$f; + var IS_BROWSER = engineIsBrowser; + var IS_DENO = engineIsDeno; + var V8_VERSION = engineV8Version; + + NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype; + var SPECIES$1 = wellKnownSymbol$8('species'); + var SUBCLASSING = false; + var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$7(global$5.PromiseRejectionEvent); + + var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES$1] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1; + }); + + var promiseConstructorDetection = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1, + SUBCLASSING: SUBCLASSING + }; + + var newPromiseCapability$2 = {}; + + var aCallable$4 = aCallable$8; + + var $TypeError$2 = TypeError; + + var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError$2('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable$4(resolve); + this.reject = aCallable$4(reject); + }; + + // `NewPromiseCapability` abstract operation + // https://tc39.es/ecma262/#sec-newpromisecapability + newPromiseCapability$2.f = function (C) { + return new PromiseCapability(C); + }; + + var $$a = _export; + var IS_NODE = engineIsNode; + var global$4 = global$k; + var call$7 = functionCall; + var defineBuiltIn$5 = defineBuiltIn$8; + var setPrototypeOf$2 = objectSetPrototypeOf; + var setToStringTag$4 = setToStringTag$5; + var setSpecies = setSpecies$1; + var aCallable$3 = aCallable$8; + var isCallable$6 = isCallable$m; + var isObject$8 = isObject$e; + var anInstance$2 = anInstance$3; + var speciesConstructor = speciesConstructor$1; + var task = task$1.set; + var microtask = microtask_1; + var hostReportErrors = hostReportErrors$1; + var perform$2 = perform$3; + var Queue = queue$1; + var InternalStateModule$3 = internalState; + var NativePromiseConstructor$2 = promiseNativeConstructor; + var PromiseConstructorDetection = promiseConstructorDetection; + var newPromiseCapabilityModule$3 = newPromiseCapability$2; + + var PROMISE = 'Promise'; + var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR; + var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; + var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; + var getInternalPromiseState = InternalStateModule$3.getterFor(PROMISE); + var setInternalState$3 = InternalStateModule$3.set; + var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype; + var PromiseConstructor = NativePromiseConstructor$2; + var PromisePrototype = NativePromisePrototype$1; + var TypeError$1 = global$4.TypeError; + var document$1 = global$4.document; + var process = global$4.process; + var newPromiseCapability$1 = newPromiseCapabilityModule$3.f; + var newGenericPromiseCapability = newPromiseCapability$1; + + var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$4.dispatchEvent); + var UNHANDLED_REJECTION = 'unhandledrejection'; + var REJECTION_HANDLED = 'rejectionhandled'; + var PENDING = 0; + var FULFILLED = 1; + var REJECTED = 2; + var HANDLED = 1; + var UNHANDLED = 2; + + var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + + // helpers + var isThenable = function (it) { + var then; + return isObject$8(it) && isCallable$6(then = it.then) ? then : false; + }; + + var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$7(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } + }; + + var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); + }; + + var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$1.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global$4.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$4['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); + }; + + var onUnhandled = function (state) { + call$7(task, global$4, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform$2(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); + }; + + var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; + }; + + var onHandleUnhandled = function (state) { + call$7(task, global$4, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); + }; + + var bind$2 = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; + }; + + var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); + }; + + var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call$7(then, value, + bind$2(internalResolve, wrapper, state), + bind$2(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } + }; + + // constructor polyfill + if (FORCED_PROMISE_CONSTRUCTOR$4) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance$2(this, PromisePrototype); + aCallable$3(executor); + call$7(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind$2(internalResolve, state), bind$2(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState$3(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: undefined + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn$5(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable$6(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$6(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind$2(internalResolve, state); + this.reject = bind$2(internalReject, state); + }; + + newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (isCallable$6(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) { + nativeThen = NativePromisePrototype$1.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn$5(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call$7(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype$1.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf$2) { + setPrototypeOf$2(NativePromisePrototype$1, PromisePrototype); + } + } + } + + $$a({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, { + Promise: PromiseConstructor + }); + + setToStringTag$4(PromiseConstructor, PROMISE, false); + setSpecies(PROMISE); + + var iterators = {}; + + var wellKnownSymbol$7 = wellKnownSymbol$f; + var Iterators$4 = iterators; + + var ITERATOR$5 = wellKnownSymbol$7('iterator'); + var ArrayPrototype$1 = Array.prototype; + + // check on default Array iterator + var isArrayIteratorMethod$1 = function (it) { + return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$5] === it); + }; + + var classof$4 = classof$8; + var getMethod$1 = getMethod$3; + var isNullOrUndefined$2 = isNullOrUndefined$6; + var Iterators$3 = iterators; + var wellKnownSymbol$6 = wellKnownSymbol$f; + + var ITERATOR$4 = wellKnownSymbol$6('iterator'); + + var getIteratorMethod$2 = function (it) { + if (!isNullOrUndefined$2(it)) return getMethod$1(it, ITERATOR$4) + || getMethod$1(it, '@@iterator') + || Iterators$3[classof$4(it)]; + }; + + var call$6 = functionCall; + var aCallable$2 = aCallable$8; + var anObject$6 = anObject$b; + var tryToString$1 = tryToString$4; + var getIteratorMethod$1 = getIteratorMethod$2; + + var $TypeError$1 = TypeError; + + var getIterator$1 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator; + if (aCallable$2(iteratorMethod)) return anObject$6(call$6(iteratorMethod, argument)); + throw new $TypeError$1(tryToString$1(argument) + ' is not iterable'); + }; + + var call$5 = functionCall; + var anObject$5 = anObject$b; + var getMethod = getMethod$3; + + var iteratorClose$1 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$5(iterator); + try { + innerResult = getMethod(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$5(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$5(innerResult); + return value; + }; + + var bind$1 = functionBindContext; + var call$4 = functionCall; + var anObject$4 = anObject$b; + var tryToString = tryToString$4; + var isArrayIteratorMethod = isArrayIteratorMethod$1; + var lengthOfArrayLike$2 = lengthOfArrayLike$4; + var isPrototypeOf = objectIsPrototypeOf; + var getIterator = getIterator$1; + var getIteratorMethod = getIteratorMethod$2; + var iteratorClose = iteratorClose$1; + + var $TypeError = TypeError; + + var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; + }; + + var ResultPrototype = Result.prototype; + + var iterate$4 = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind$1(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject$4(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = lengthOfArrayLike$2(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call$4(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + }; + + var wellKnownSymbol$5 = wellKnownSymbol$f; + + var ITERATOR$3 = wellKnownSymbol$5('iterator'); + var SAFE_CLOSING = false; + + try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR$3] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); + } catch (error) { /* empty */ } + + var checkCorrectnessOfIteration$2 = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR$3] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; + }; + + var NativePromiseConstructor$1 = promiseNativeConstructor; + var checkCorrectnessOfIteration$1 = checkCorrectnessOfIteration$2; + var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR; + + var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration$1(function (iterable) { + NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ }); + }); + + var $$9 = _export; + var call$3 = functionCall; + var aCallable$1 = aCallable$8; + var newPromiseCapabilityModule$2 = newPromiseCapability$2; + var perform$1 = perform$3; + var iterate$3 = iterate$4; + var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration; + + // `Promise.all` method + // https://tc39.es/ecma262/#sec-promise.all + $$9({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$2.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform$1(function () { + var $promiseResolve = aCallable$1(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$3(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$3($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var $$8 = _export; + var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR; + var NativePromiseConstructor = promiseNativeConstructor; + var getBuiltIn$1 = getBuiltIn$7; + var isCallable$5 = isCallable$m; + var defineBuiltIn$4 = defineBuiltIn$8; + + var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + + // `Promise.prototype.catch` method + // https://tc39.es/ecma262/#sec-promise.prototype.catch + $$8({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + + // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` + if (isCallable$5(NativePromiseConstructor)) { + var method = getBuiltIn$1('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn$4(NativePromisePrototype, 'catch', method, { unsafe: true }); + } + } + + var $$7 = _export; + var call$2 = functionCall; + var aCallable = aCallable$8; + var newPromiseCapabilityModule$1 = newPromiseCapability$2; + var perform = perform$3; + var iterate$2 = iterate$4; + var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration; + + // `Promise.race` method + // https://tc39.es/ecma262/#sec-promise.race + $$7({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$1.f(C); + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aCallable(C.resolve); + iterate$2(iterable, function (promise) { + call$2($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var $$6 = _export; + var call$1 = functionCall; + var newPromiseCapabilityModule = newPromiseCapability$2; + var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR; + + // `Promise.reject` method + // https://tc39.es/ecma262/#sec-promise.reject + $$6({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule.f(this); + call$1(capability.reject, undefined, r); + return capability.promise; + } + }); + + var anObject$3 = anObject$b; + var isObject$7 = isObject$e; + var newPromiseCapability = newPromiseCapability$2; + + var promiseResolve$1 = function (C, x) { + anObject$3(C); + if (isObject$7(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; + }; + + var $$5 = _export; + var getBuiltIn = getBuiltIn$7; + var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR; + var promiseResolve = promiseResolve$1; + + getBuiltIn('Promise'); + + // `Promise.resolve` method + // https://tc39.es/ecma262/#sec-promise.resolve + $$5({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(this, x); + } + }); + + var fails$7 = fails$j; + + var arrayMethodIsStrict$2 = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails$7(function () { + // eslint-disable-next-line no-useless-call -- required for testing + method.call(null, argument || function () { return 1; }, 1); + }); + }; + + var $$4 = _export; + var uncurryThis$5 = functionUncurryThis; + var IndexedObject$1 = indexedObject; + var toIndexedObject$3 = toIndexedObject$7; + var arrayMethodIsStrict$1 = arrayMethodIsStrict$2; + + var nativeJoin = uncurryThis$5([].join); + + var ES3_STRINGS = IndexedObject$1 !== Object; + var FORCED = ES3_STRINGS || !arrayMethodIsStrict$1('join', ','); + + // `Array.prototype.join` method + // https://tc39.es/ecma262/#sec-array.prototype.join + $$4({ target: 'Array', proto: true, forced: FORCED }, { + join: function join(separator) { + return nativeJoin(toIndexedObject$3(this), separator === undefined ? ',' : separator); + } + }); + + var objectDefineProperties = {}; + + var DESCRIPTORS$1 = descriptors; + var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; + var definePropertyModule$1 = objectDefineProperty; + var anObject$2 = anObject$b; + var toIndexedObject$2 = toIndexedObject$7; + var objectKeys = objectKeys$2; + + // `Object.defineProperties` method + // https://tc39.es/ecma262/#sec-object.defineproperties + // eslint-disable-next-line es/no-object-defineproperties -- safe + objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject$2(O); + var props = toIndexedObject$2(Properties); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]); + return O; + }; + + /* global ActiveXObject -- old IE, WSH */ + var anObject$1 = anObject$b; + var definePropertiesModule = objectDefineProperties; + var enumBugKeys = enumBugKeys$3; + var hiddenKeys$1 = hiddenKeys$5; + var html = html$2; + var documentCreateElement$1 = documentCreateElement$2; + var sharedKey$1 = sharedKey$3; + + var GT = '>'; + var LT = '<'; + var PROTOTYPE = 'prototype'; + var SCRIPT = 'script'; + var IE_PROTO$1 = sharedKey$1('IE_PROTO'); + + var EmptyConstructor = function () { /* empty */ }; + + var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; + }; + + // Create object with fake `null` prototype: use ActiveX Object with cleared prototype + var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; + }; + + // Create object with fake `null` prototype: use iframe Object with cleared prototype + var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement$1('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; + }; + + // Check for document.domain and active x support + // No need to use active x approach when document.domain is not set + // see https://github.com/es-shims/es5-shim/issues/150 + // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 + // avoid IE GC bug + var activeXDocument; + var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); + }; + + hiddenKeys$1[IE_PROTO$1] = true; + + // `Object.create` method + // https://tc39.es/ecma262/#sec-object.create + // eslint-disable-next-line es/no-object-create -- safe + var objectCreate = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject$1(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO$1] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : definePropertiesModule.f(result, Properties); + }; + + var wellKnownSymbol$4 = wellKnownSymbol$f; + var create$1 = objectCreate; + var defineProperty$2 = objectDefineProperty.f; + + var UNSCOPABLES = wellKnownSymbol$4('unscopables'); + var ArrayPrototype = Array.prototype; + + // Array.prototype[@@unscopables] + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + if (ArrayPrototype[UNSCOPABLES] === undefined) { + defineProperty$2(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create$1(null) + }); + } + + // add a key to Array.prototype[@@unscopables] + var addToUnscopables$1 = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; + }; + + var fails$6 = fails$j; + + var correctPrototypeGetter = !fails$6(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; + }); + + var hasOwn$2 = hasOwnProperty_1; + var isCallable$4 = isCallable$m; + var toObject$2 = toObject$5; + var sharedKey = sharedKey$3; + var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter; + + var IE_PROTO = sharedKey('IE_PROTO'); + var $Object = Object; + var ObjectPrototype = $Object.prototype; + + // `Object.getPrototypeOf` method + // https://tc39.es/ecma262/#sec-object.getprototypeof + // eslint-disable-next-line es/no-object-getprototypeof -- safe + var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) { + var object = toObject$2(O); + if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable$4(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof $Object ? ObjectPrototype : null; + }; + + var fails$5 = fails$j; + var isCallable$3 = isCallable$m; + var isObject$6 = isObject$e; + var getPrototypeOf$1 = objectGetPrototypeOf; + var defineBuiltIn$3 = defineBuiltIn$8; + var wellKnownSymbol$3 = wellKnownSymbol$f; + + var ITERATOR$2 = wellKnownSymbol$3('iterator'); + var BUGGY_SAFARI_ITERATORS$1 = false; + + // `%IteratorPrototype%` object + // https://tc39.es/ecma262/#sec-%iteratorprototype%-object + var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator; + + /* eslint-disable es/no-array-prototype-keys -- safe */ + if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype; + } + } + + var NEW_ITERATOR_PROTOTYPE = !isObject$6(IteratorPrototype$2) || fails$5(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype$2[ITERATOR$2].call(test) !== test; + }); + + if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {}; + + // `%IteratorPrototype%[@@iterator]()` method + // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator + if (!isCallable$3(IteratorPrototype$2[ITERATOR$2])) { + defineBuiltIn$3(IteratorPrototype$2, ITERATOR$2, function () { + return this; + }); + } + + var iteratorsCore = { + IteratorPrototype: IteratorPrototype$2, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1 + }; + + var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; + var create = objectCreate; + var createPropertyDescriptor$1 = createPropertyDescriptor$4; + var setToStringTag$3 = setToStringTag$5; + var Iterators$2 = iterators; + + var returnThis$1 = function () { return this; }; + + var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next) }); + setToStringTag$3(IteratorConstructor, TO_STRING_TAG, false); + Iterators$2[TO_STRING_TAG] = returnThis$1; + return IteratorConstructor; + }; + + var $$3 = _export; + var call = functionCall; + var FunctionName = functionName; + var isCallable$2 = isCallable$m; + var createIteratorConstructor = iteratorCreateConstructor; + var getPrototypeOf = objectGetPrototypeOf; + var setPrototypeOf$1 = objectSetPrototypeOf; + var setToStringTag$2 = setToStringTag$5; + var createNonEnumerableProperty$2 = createNonEnumerableProperty$5; + var defineBuiltIn$2 = defineBuiltIn$8; + var wellKnownSymbol$2 = wellKnownSymbol$f; + var Iterators$1 = iterators; + var IteratorsCore = iteratorsCore; + + var PROPER_FUNCTION_NAME = FunctionName.PROPER; + var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; + var IteratorPrototype = IteratorsCore.IteratorPrototype; + var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; + var ITERATOR$1 = wellKnownSymbol$2('iterator'); + var KEYS = 'keys'; + var VALUES = 'values'; + var ENTRIES = 'entries'; + + var returnThis = function () { return this; }; + + var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND]; + + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } + + return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR$1] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf$1) { + setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$1])) { + defineBuiltIn$2(CurrentIteratorPrototype, ITERATOR$1, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag$2(CurrentIteratorPrototype, TO_STRING_TAG, true); + } + } + + // fix Array.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call(nativeIterator, this); }; + } + } + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + defineBuiltIn$2(IterablePrototype, KEY, methods[KEY]); + } + } else $$3({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if (IterablePrototype[ITERATOR$1] !== defaultIterator) { + defineBuiltIn$2(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT }); + } + Iterators$1[NAME] = defaultIterator; + + return methods; + }; + + // `CreateIterResultObject` abstract operation + // https://tc39.es/ecma262/#sec-createiterresultobject + var createIterResultObject$2 = function (value, done) { + return { value: value, done: done }; + }; + + var toIndexedObject$1 = toIndexedObject$7; + var addToUnscopables = addToUnscopables$1; + var Iterators = iterators; + var InternalStateModule$2 = internalState; + var defineProperty$1 = objectDefineProperty.f; + var defineIterator$1 = iteratorDefine; + var createIterResultObject$1 = createIterResultObject$2; + var DESCRIPTORS = descriptors; + + var ARRAY_ITERATOR = 'Array Iterator'; + var setInternalState$2 = InternalStateModule$2.set; + var getInternalState$1 = InternalStateModule$2.getterFor(ARRAY_ITERATOR); + + // `Array.prototype.entries` method + // https://tc39.es/ecma262/#sec-array.prototype.entries + // `Array.prototype.keys` method + // https://tc39.es/ecma262/#sec-array.prototype.keys + // `Array.prototype.values` method + // https://tc39.es/ecma262/#sec-array.prototype.values + // `Array.prototype[@@iterator]` method + // https://tc39.es/ecma262/#sec-array.prototype-@@iterator + // `CreateArrayIterator` internal method + // https://tc39.es/ecma262/#sec-createarrayiterator + var es_array_iterator = defineIterator$1(Array, 'Array', function (iterated, kind) { + setInternalState$2(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject$1(iterated), // target + index: 0, // next index + kind: kind // kind + }); + // `%ArrayIteratorPrototype%.next` method + // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next + }, function () { + var state = getInternalState$1(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return createIterResultObject$1(undefined, true); + } + switch (state.kind) { + case 'keys': return createIterResultObject$1(index, false); + case 'values': return createIterResultObject$1(target[index], false); + } return createIterResultObject$1([index, target[index]], false); + }, 'values'); + + // argumentsList[@@iterator] is %ArrayProto_values% + // https://tc39.es/ecma262/#sec-createunmappedargumentsobject + // https://tc39.es/ecma262/#sec-createmappedargumentsobject + var values = Iterators.Arguments = Iterators.Array; + + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + addToUnscopables('keys'); + addToUnscopables('values'); + addToUnscopables('entries'); + + // V8 ~ Chrome 45- bug + if (DESCRIPTORS && values.name !== 'values') try { + defineProperty$1(values, 'name', { value: 'values' }); + } catch (error) { /* empty */ } + + var classof$3 = classof$8; + + var $String = String; + + var toString$2 = function (argument) { + if (classof$3(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string'); + return $String(argument); + }; + + var uncurryThis$4 = functionUncurryThis; + var toIntegerOrInfinity = toIntegerOrInfinity$3; + var toString$1 = toString$2; + var requireObjectCoercible = requireObjectCoercible$3; + + var charAt$1 = uncurryThis$4(''.charAt); + var charCodeAt = uncurryThis$4(''.charCodeAt); + var stringSlice = uncurryThis$4(''.slice); + + var createMethod$1 = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = toString$1(requireObjectCoercible($this)); + var position = toIntegerOrInfinity(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = charCodeAt(S, position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt$1(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; + }; + + var stringMultibyte = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod$1(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod$1(true) + }; + + var charAt = stringMultibyte.charAt; + var toString = toString$2; + var InternalStateModule$1 = internalState; + var defineIterator = iteratorDefine; + var createIterResultObject = createIterResultObject$2; + + var STRING_ITERATOR = 'String Iterator'; + var setInternalState$1 = InternalStateModule$1.set; + var getInternalState = InternalStateModule$1.getterFor(STRING_ITERATOR); + + // `String.prototype[@@iterator]` method + // https://tc39.es/ecma262/#sec-string.prototype-@@iterator + defineIterator(String, 'String', function (iterated) { + setInternalState$1(this, { + type: STRING_ITERATOR, + string: toString(iterated), + index: 0 + }); + // `%StringIteratorPrototype%.next` method + // https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next + }, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return createIterResultObject(undefined, true); + point = charAt(string, index); + state.index += point.length; + return createIterResultObject(point, false); + }); + + var internalMetadata = {exports: {}}; + + var objectGetOwnPropertyNamesExternal = {}; + + var toPropertyKey = toPropertyKey$3; + var definePropertyModule = objectDefineProperty; + var createPropertyDescriptor = createPropertyDescriptor$4; + + var createProperty$1 = function (object, key, value) { + var propertyKey = toPropertyKey(key); + if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; + }; + + var toAbsoluteIndex = toAbsoluteIndex$2; + var lengthOfArrayLike$1 = lengthOfArrayLike$4; + var createProperty = createProperty$1; + + var $Array$1 = Array; + var max = Math.max; + + var arraySliceSimple = function (O, start, end) { + var length = lengthOfArrayLike$1(O); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + var result = $Array$1(max(fin - k, 0)); + var n = 0; + for (; k < fin; k++, n++) createProperty(result, n, O[k]); + result.length = n; + return result; + }; + + /* eslint-disable es/no-object-getownpropertynames -- safe */ + var classof$2 = classofRaw$2; + var toIndexedObject = toIndexedObject$7; + var $getOwnPropertyNames = objectGetOwnPropertyNames.f; + var arraySlice = arraySliceSimple; + + var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + + var getWindowNames = function (it) { + try { + return $getOwnPropertyNames(it); + } catch (error) { + return arraySlice(windowNames); + } + }; + + // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window + objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames(it) { + return windowNames && classof$2(it) === 'Window' + ? getWindowNames(it) + : $getOwnPropertyNames(toIndexedObject(it)); + }; + + // FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it + var fails$4 = fails$j; + + var arrayBufferNonExtensible = fails$4(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } + }); + + var fails$3 = fails$j; + var isObject$5 = isObject$e; + var classof$1 = classofRaw$2; + var ARRAY_BUFFER_NON_EXTENSIBLE = arrayBufferNonExtensible; + + // eslint-disable-next-line es/no-object-isextensible -- safe + var $isExtensible = Object.isExtensible; + var FAILS_ON_PRIMITIVES$1 = fails$3(function () { $isExtensible(1); }); + + // `Object.isExtensible` method + // https://tc39.es/ecma262/#sec-object.isextensible + var objectIsExtensible = (FAILS_ON_PRIMITIVES$1 || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) { + if (!isObject$5(it)) return false; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof$1(it) === 'ArrayBuffer') return false; + return $isExtensible ? $isExtensible(it) : true; + } : $isExtensible; + + var fails$2 = fails$j; + + var freezing = !fails$2(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); + }); + + var $$2 = _export; + var uncurryThis$3 = functionUncurryThis; + var hiddenKeys = hiddenKeys$5; + var isObject$4 = isObject$e; + var hasOwn$1 = hasOwnProperty_1; + var defineProperty = objectDefineProperty.f; + var getOwnPropertyNamesModule = objectGetOwnPropertyNames; + var getOwnPropertyNamesExternalModule = objectGetOwnPropertyNamesExternal; + var isExtensible = objectIsExtensible; + var uid = uid$3; + var FREEZING = freezing; + + var REQUIRED = false; + var METADATA = uid('meta'); + var id$1 = 0; + + var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + id$1++, // object ID + weakData: {} // weak collections IDs + } }); + }; + + var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject$4(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; + }; + + var getWeakData$1 = function (it, create) { + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; + }; + + // add metadata on freeze-family methods calling + var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn$1(it, METADATA)) setMetadata(it); + return it; + }; + + var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis$3([].splice); + var test = {}; + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $$2({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } + }; + + var meta = internalMetadata.exports = { + enable: enable, + fastKey: fastKey, + getWeakData: getWeakData$1, + onFreeze: onFreeze + }; + + hiddenKeys[METADATA] = true; + + var internalMetadataExports = internalMetadata.exports; + + var isCallable$1 = isCallable$m; + var isObject$3 = isObject$e; + var setPrototypeOf = objectSetPrototypeOf; + + // makes subclassing work correct for wrapped built-ins + var inheritIfRequired$1 = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable$1(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject$3(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; + }; + + var $$1 = _export; + var global$3 = global$k; + var uncurryThis$2 = functionUncurryThis; + var isForced = isForced_1; + var defineBuiltIn$1 = defineBuiltIn$8; + var InternalMetadataModule = internalMetadataExports; + var iterate$1 = iterate$4; + var anInstance$1 = anInstance$3; + var isCallable = isCallable$m; + var isNullOrUndefined$1 = isNullOrUndefined$6; + var isObject$2 = isObject$e; + var fails$1 = fails$j; + var checkCorrectnessOfIteration = checkCorrectnessOfIteration$2; + var setToStringTag$1 = setToStringTag$5; + var inheritIfRequired = inheritIfRequired$1; + + var collection$1 = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global$3[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis$2(NativePrototype[KEY]); + defineBuiltIn$1(NativePrototype, KEY, + KEY === 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY === 'delete' ? function (key) { + return IS_WEAK && !isObject$2(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'get' ? function get(key) { + return IS_WEAK && !isObject$2(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'has' ? function has(key) { + return IS_WEAK && !isObject$2(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails$1(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails$1(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails$1(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance$1(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (!isNullOrUndefined$1(iterable)) iterate$1(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $$1({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported); + + setToStringTag$1(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; + }; + + var defineBuiltIn = defineBuiltIn$8; + + var defineBuiltIns$1 = function (target, src, options) { + for (var key in src) defineBuiltIn(target, key, src[key], options); + return target; + }; + + var classof = classofRaw$2; + + // `IsArray` abstract operation + // https://tc39.es/ecma262/#sec-isarray + // eslint-disable-next-line es/no-array-isarray -- safe + var isArray$1 = Array.isArray || function isArray(argument) { + return classof(argument) === 'Array'; + }; + + var isArray = isArray$1; + var isConstructor = isConstructor$2; + var isObject$1 = isObject$e; + var wellKnownSymbol$1 = wellKnownSymbol$f; + + var SPECIES = wellKnownSymbol$1('species'); + var $Array = Array; + + // a part of `ArraySpeciesCreate` abstract operation + // https://tc39.es/ecma262/#sec-arrayspeciescreate + var arraySpeciesConstructor$1 = function (originalArray) { + var C; + if (isArray(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined; + else if (isObject$1(C)) { + C = C[SPECIES]; + if (C === null) C = undefined; + } + } return C === undefined ? $Array : C; + }; + + var arraySpeciesConstructor = arraySpeciesConstructor$1; + + // `ArraySpeciesCreate` abstract operation + // https://tc39.es/ecma262/#sec-arrayspeciescreate + var arraySpeciesCreate$1 = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); + }; + + var bind = functionBindContext; + var uncurryThis$1 = functionUncurryThis; + var IndexedObject = indexedObject; + var toObject$1 = toObject$5; + var lengthOfArrayLike = lengthOfArrayLike$4; + var arraySpeciesCreate = arraySpeciesCreate$1; + + var push = uncurryThis$1([].push); + + // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation + var createMethod = function (TYPE) { + var IS_MAP = TYPE === 1; + var IS_FILTER = TYPE === 2; + var IS_SOME = TYPE === 3; + var IS_EVERY = TYPE === 4; + var IS_FIND_INDEX = TYPE === 6; + var IS_FILTER_REJECT = TYPE === 7; + var NO_HOLES = TYPE === 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject$1($this); + var self = IndexedObject(O); + var length = lengthOfArrayLike(self); + var boundFunction = bind(callbackfn, that); + var index = 0; + var create = specificCreate || arraySpeciesCreate; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push(target, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; + }; + + var arrayIteration = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod(7) + }; + + var uncurryThis = functionUncurryThis; + var defineBuiltIns = defineBuiltIns$1; + var getWeakData = internalMetadataExports.getWeakData; + var anInstance = anInstance$3; + var anObject = anObject$b; + var isNullOrUndefined = isNullOrUndefined$6; + var isObject = isObject$e; + var iterate = iterate$4; + var ArrayIterationModule = arrayIteration; + var hasOwn = hasOwnProperty_1; + var InternalStateModule = internalState; + + var setInternalState = InternalStateModule.set; + var internalStateGetterFor = InternalStateModule.getterFor; + var find = ArrayIterationModule.find; + var findIndex = ArrayIterationModule.findIndex; + var splice = uncurryThis([].splice); + var id = 0; + + // fallback for uncaught frozen keys + var uncaughtFrozenStore = function (state) { + return state.frozen || (state.frozen = new UncaughtFrozenStore()); + }; + + var UncaughtFrozenStore = function () { + this.entries = []; + }; + + var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); + }; + + UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) splice(this.entries, index, 1); + return !!~index; + } + }; + + var collectionWeak$1 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + defineBuiltIns(Prototype, { + // `{ WeakMap, WeakSet }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.delete + // https://tc39.es/ecma262/#sec-weakset.prototype.delete + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && hasOwn(data, state.id) && delete data[state.id]; + }, + // `{ WeakMap, WeakSet }.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.has + // https://tc39.es/ecma262/#sec-weakset.prototype.has + has: function has(key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && hasOwn(data, state.id); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `WeakMap.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.get + get: function get(key) { + var state = getInternalState(this); + if (isObject(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // `WeakMap.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.set + set: function set(key, value) { + return define(this, key, value); + } + } : { + // `WeakSet.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-weakset.prototype.add + add: function add(value) { + return define(this, value, true); + } + }); + + return Constructor; + } + }; + + var collection = collection$1; + var collectionWeak = collectionWeak$1; + + // `WeakSet` constructor + // https://tc39.es/ecma262/#sec-weakset-constructor + collection('WeakSet', function (init) { + return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); }; + }, collectionWeak); + + // iterable DOM collections + // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods + var domIterables = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 + }; + + // in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList` + var documentCreateElement = documentCreateElement$2; + + var classList = documentCreateElement('span').classList; + var DOMTokenListPrototype$2 = classList && classList.constructor && classList.constructor.prototype; + + var domTokenListPrototype = DOMTokenListPrototype$2 === Object.prototype ? undefined : DOMTokenListPrototype$2; + + var global$2 = global$k; + var DOMIterables$1 = domIterables; + var DOMTokenListPrototype$1 = domTokenListPrototype; + var ArrayIteratorMethods = es_array_iterator; + var createNonEnumerableProperty$1 = createNonEnumerableProperty$5; + var setToStringTag = setToStringTag$5; + var wellKnownSymbol = wellKnownSymbol$f; + + var ITERATOR = wellKnownSymbol('iterator'); + var ArrayValues = ArrayIteratorMethods.values; + + var handlePrototype$1 = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty$1(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + setToStringTag(CollectionPrototype, COLLECTION_NAME, true); + if (DOMIterables$1[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty$1(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } + }; + + for (var COLLECTION_NAME$1 in DOMIterables$1) { + handlePrototype$1(global$2[COLLECTION_NAME$1] && global$2[COLLECTION_NAME$1].prototype, COLLECTION_NAME$1); + } + + handlePrototype$1(DOMTokenListPrototype$1, 'DOMTokenList'); + + var $forEach = arrayIteration.forEach; + var arrayMethodIsStrict = arrayMethodIsStrict$2; + + var STRICT_METHOD = arrayMethodIsStrict('forEach'); + + // `Array.prototype.forEach` method implementation + // https://tc39.es/ecma262/#sec-array.prototype.foreach + var arrayForEach = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + // eslint-disable-next-line es/no-array-prototype-foreach -- safe + } : [].forEach; + + var global$1 = global$k; + var DOMIterables = domIterables; + var DOMTokenListPrototype = domTokenListPrototype; + var forEach = arrayForEach; + var createNonEnumerableProperty = createNonEnumerableProperty$5; + + var handlePrototype = function (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { + createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach); + } catch (error) { + CollectionPrototype.forEach = forEach; + } + }; + + for (var COLLECTION_NAME in DOMIterables) { + if (DOMIterables[COLLECTION_NAME]) { + handlePrototype(global$1[COLLECTION_NAME] && global$1[COLLECTION_NAME].prototype); + } + } + + handlePrototype(DOMTokenListPrototype); + + var $ = _export; + var toObject = toObject$5; + var nativeKeys = objectKeys$2; + var fails = fails$j; + + var FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); }); + + // `Object.keys` method + // https://tc39.es/ecma262/#sec-object.keys + $({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { + keys: function keys(it) { + return nativeKeys(toObject(it)); + } + }); + + /****************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + /* global Reflect, Promise */ + + + function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); + } + + var ScrollDirection; + (function (ScrollDirection) { + ScrollDirection[ScrollDirection["SCROLL_NONE"] = 0] = "SCROLL_NONE"; + ScrollDirection[ScrollDirection["SCROLL_BACKWARD"] = 1] = "SCROLL_BACKWARD"; + ScrollDirection[ScrollDirection["SCROLL_FORWARD"] = 2] = "SCROLL_FORWARD"; + })(ScrollDirection || (ScrollDirection = {})); + var Position; + (function (Position) { + Position[Position["TOP"] = 0] = "TOP"; + Position[Position["RIGHT"] = 1] = "RIGHT"; + Position[Position["BOTTOM"] = 2] = "BOTTOM"; + Position[Position["LEFT"] = 3] = "LEFT"; + })(Position || (Position = {})); + + function isHorizontal(position) { + return position === 'left' || position === 'right'; + } + function isVertical(position) { + return position === 'top' || position === 'bottom'; + } + function horizontalPadding(padding) { + return padding[Position.LEFT] + padding[Position.RIGHT]; + } + function verticalPadding(padding) { + return padding[Position.TOP] + padding[Position.BOTTOM]; + } + + var _CalendarLabel_instances, _CalendarLabel_buildComputedOptions, _CalendarLabel_computeDimensions, _CalendarLabel_setRectAttr, _CalendarLabel_setTextAttr, _CalendarLabel_getTextXOffset, _CalendarLabel_getX, _CalendarLabel_getY; + var DEFAULT_SELECTOR = '.ch-plugin-calendar-label'; + var defaultOptions = { + enabled: true, + dimensions: { + width: 0, + height: 0 + }, + position: 'left', + text: function text() { + return []; + }, + padding: [0, 0, 0, 0] + }; + var CalendarLabel = /*#__PURE__*/function () { + function CalendarLabel(calendar) { + _classCallCheck(this, CalendarLabel); + var _a, _b; + _CalendarLabel_instances.add(this); + this.name = 'CalendarLabel'; + var subDomain = (_b = (_a = calendar === null || calendar === void 0 ? void 0 : calendar.options) === null || _a === void 0 ? void 0 : _a.options) === null || _b === void 0 ? void 0 : _b.subDomain; + this.calendar = calendar; + this.root = null; + this.shown = false; + this.options = defaultOptions; + this.computedOptions = { + radius: subDomain === null || subDomain === void 0 ? void 0 : subDomain.radius, + width: subDomain === null || subDomain === void 0 ? void 0 : subDomain.width, + height: subDomain === null || subDomain === void 0 ? void 0 : subDomain.height, + gutter: subDomain === null || subDomain === void 0 ? void 0 : subDomain.gutter, + textAlign: 'start' + }; + } + _createClass(CalendarLabel, [{ + key: "setup", + value: function setup(pluginOptions) { + this.options = Object.assign(Object.assign({}, defaultOptions), pluginOptions); + } + }, { + key: "paint", + value: function paint() { + var enabled = this.options.enabled; + if (!enabled) { + return this.destroy(); + } + this.shown = true; + var calendarRoot = this.calendar.calendarPainter.root; + if (!this.root) { + this.root = calendarRoot.append('svg').attr('class', DEFAULT_SELECTOR.slice(1)).attr('data-key', this.options.key).attr('x', 0).attr('y', 0); + } + this.build(); + return Promise.resolve(); + } + }, { + key: "destroy", + value: function destroy() { + if (this.root !== null) { + this.root.remove(); + this.root = null; + } + return Promise.resolve(); + } + }, { + key: "build", + value: function build() { + var _this = this; + __classPrivateFieldGet(this, _CalendarLabel_instances, "m", _CalendarLabel_buildComputedOptions).call(this); + __classPrivateFieldGet(this, _CalendarLabel_instances, "m", _CalendarLabel_computeDimensions).call(this); + this.root.selectAll('g').data(this.options.text).join(function (enter) { + return enter.append('g').call(function (selection) { + return selection.append('rect').attr('class', "".concat(DEFAULT_SELECTOR.slice(1), "-bg")).attr('style', 'fill: transparent').call(function (s) { + return __classPrivateFieldGet(_this, _CalendarLabel_instances, "m", _CalendarLabel_setRectAttr).call(_this, s); + }); + }).call(function (selection) { + return selection.append('text').attr('class', "".concat(DEFAULT_SELECTOR.slice(1), "-text")).attr('dominant-baseline', 'central').attr('text-anchor', 'middle').attr('style', 'fill: currentColor; font-size: 10px').call(function (s) { + return __classPrivateFieldGet(_this, _CalendarLabel_instances, "m", _CalendarLabel_setTextAttr).call(_this, s); + }); + }); + }); + return Promise.resolve(); + } + }]); + return CalendarLabel; + }(); + _CalendarLabel_instances = new WeakSet(), _CalendarLabel_buildComputedOptions = function _CalendarLabel_buildComputedOptions() { + var _this2 = this; + Object.keys(this.computedOptions).forEach(function (key) { + if (typeof _this2.options[key] !== 'undefined') { + // @ts-ignore + _this2.computedOptions[key] = _this2.options[key]; + } + }); + }, _CalendarLabel_computeDimensions = function _CalendarLabel_computeDimensions() { + var _this$computedOptions = this.computedOptions, + width = _this$computedOptions.width, + height = _this$computedOptions.height, + gutter = _this$computedOptions.gutter; + var _this$options = this.options, + text = _this$options.text, + padding = _this$options.padding, + position = _this$options.position; + var labelsCount = text().length; + this.options.dimensions = { + width: width + horizontalPadding(padding), + height: height + verticalPadding(padding) + }; + if (isVertical(position)) { + this.options.dimensions.width += (width + gutter) * (labelsCount - 1); + } else { + this.options.dimensions.height += (height + gutter) * (labelsCount - 1); + } + }, _CalendarLabel_setRectAttr = function _CalendarLabel_setRectAttr(selection) { + var _this3 = this; + var _this$computedOptions2 = this.computedOptions, + width = _this$computedOptions2.width, + height = _this$computedOptions2.height, + radius = _this$computedOptions2.radius; + selection.attr('width', width).attr('height', height).attr('rx', radius && radius > 0 ? radius : null).attr('ry', radius && radius > 0 ? radius : null).attr('x', function (_d, i) { + return __classPrivateFieldGet(_this3, _CalendarLabel_instances, "m", _CalendarLabel_getX).call(_this3, i); + }).attr('y', function (_d, i) { + return __classPrivateFieldGet(_this3, _CalendarLabel_instances, "m", _CalendarLabel_getY).call(_this3, i); + }); + }, _CalendarLabel_setTextAttr = function _CalendarLabel_setTextAttr(selection) { + var _this4 = this; + var _this$computedOptions3 = this.computedOptions, + height = _this$computedOptions3.height, + textAlign = _this$computedOptions3.textAlign; + selection.attr('text-anchor', textAlign).attr('x', function (_d, i) { + return __classPrivateFieldGet(_this4, _CalendarLabel_instances, "m", _CalendarLabel_getTextXOffset).call(_this4) + __classPrivateFieldGet(_this4, _CalendarLabel_instances, "m", _CalendarLabel_getX).call(_this4, i); + }).attr('y', function (_d, i) { + return __classPrivateFieldGet(_this4, _CalendarLabel_instances, "m", _CalendarLabel_getY).call(_this4, i) + height / 2; + }).text(function (data) { + return data; + }); + }, _CalendarLabel_getTextXOffset = function _CalendarLabel_getTextXOffset() { + var _this$computedOptions4 = this.computedOptions, + width = _this$computedOptions4.width, + textAlign = _this$computedOptions4.textAlign; + switch (textAlign) { + case 'start': + return 0; + case 'middle': + return width / 2; + case 'end': + return width; + default: + return 0; + } + }, _CalendarLabel_getX = function _CalendarLabel_getX(index) { + var _this$options2 = this.options, + position = _this$options2.position, + padding = _this$options2.padding; + var _this$computedOptions5 = this.computedOptions, + width = _this$computedOptions5.width, + gutter = _this$computedOptions5.gutter; + if (isHorizontal(position)) { + return padding[Position.LEFT]; + } + return padding[Position.LEFT] + (width + gutter) * index; + }, _CalendarLabel_getY = function _CalendarLabel_getY(index) { + var _this$options3 = this.options, + position = _this$options3.position, + padding = _this$options3.padding; + var _this$computedOptions6 = this.computedOptions, + height = _this$computedOptions6.height, + gutter = _this$computedOptions6.gutter; + if (isVertical(position)) { + return padding[Position.TOP]; + } + return padding[Position.TOP] + (height + gutter) * index; + }; + + return CalendarLabel; + +})); diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.esm.js b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.esm.js new file mode 100644 index 0000000..a3e013d --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.esm.js @@ -0,0 +1 @@ +function t(t,e){for(var n=0;n0&&W[0]<4?1:+(W[0]+W[1])),!z&&bt&&(!(W=bt.match(/Edge\/(\d+)/))||W[1]>=74)&&(W=bt.match(/Chrome\/(\d+)/))&&(z=+W[1]);var jt=z,Tt=jt,Et=n,Pt=I.String,xt=!!Object.getOwnPropertySymbols&&!Et((function(){var t=Symbol("symbol detection");return!Pt(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&Tt&&Tt<41})),At=xt&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,Rt=vt,Lt=L,Ct=dt,It=Object,kt=At?function(t){return"symbol"==typeof t}:function(t){var e=Rt("Symbol");return Lt(e)&&Ct(e.prototype,It(t))},_t=String,Nt=function(t){try{return _t(t)}catch(t){return"Object"}},Dt=L,Ft=Nt,Mt=TypeError,Gt=function(t){if(Dt(t))return t;throw new Mt(Ft(t)+" is not a function")},Bt=Gt,Ut=s,Wt=function(t,e){var n=t[e];return Ut(n)?void 0:Bt(n)},zt=lt,Ht=L,Vt=J,Kt=TypeError,qt={exports:{}},Xt=M;(qt.exports=function(t,e){return Xt[t]||(Xt[t]=void 0!==e?e:{})})("versions",[]).push({version:"3.34.0",mode:"global",copyright:"© 2014-2023 Denis Pushkarev (zloirock.ru)",license:"https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE",source:"https://github.com/zloirock/core-js"});var Yt=qt.exports,Jt=f,$t=0,Qt=Math.random(),Zt=Jt(1..toString),te=function(t){return"Symbol("+(void 0===t?"":t)+")_"+Zt(++$t+Qt,36)},ee=Yt,ne=m,re=te,oe=xt,ie=At,ue=I.Symbol,ce=ee("wks"),ae=ie?ue.for||ue:ue&&ue.withoutSetter||re,fe=function(t){return ne(ce,t)||(ce[t]=oe&&ne(ue,t)?ue[t]:ae("Symbol."+t)),ce[t]},se=lt,le=J,pe=kt,he=Wt,ve=function(t,e){var n,r;if("string"===e&&Ht(n=t.toString)&&!Vt(r=zt(n,t)))return r;if(Ht(n=t.valueOf)&&!Vt(r=zt(n,t)))return r;if("string"!==e&&Ht(n=t.toString)&&!Vt(r=zt(n,t)))return r;throw new Kt("Can't convert object to primitive value")},de=TypeError,ye=fe("toPrimitive"),ge=function(t,e){if(!le(t)||pe(t))return t;var n,r=he(t,ye);if(r){if(void 0===e&&(e="default"),n=se(r,t,e),!le(n)||pe(n))return n;throw new de("Can't convert object to primitive value")}return void 0===e&&(e="number"),ve(t,e)},be=kt,me=function(t){var e=ge(t,"string");return be(e)?e:e+""},we=r,Oe=rt,Se=ot,je=at,Te=me,Ee=TypeError,Pe=Object.defineProperty,xe=Object.getOwnPropertyDescriptor,Ae="enumerable",Re="configurable",Le="writable";$.f=we?Se?function(t,e,n){if(je(t),e=Te(e),je(n),"function"==typeof t&&"prototype"===e&&"value"in n&&Le in n&&!n[Le]){var r=xe(t,e);r&&r[Le]&&(t[e]=n.value,n={configurable:Re in n?n[Re]:r[Re],enumerable:Ae in n?n[Ae]:r[Ae],writable:!1})}return Pe(t,e,n)}:Pe:function(t,e,n){if(je(t),e=Te(e),je(n),Oe)try{return Pe(t,e,n)}catch(t){}if("get"in n||"set"in n)throw new Ee("Accessors not supported");return"value"in n&&(t[e]=n.value),t};var Ce,Ie,ke,_e=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}},Ne=$,De=_e,Fe=r?function(t,e,n){return Ne.f(t,e,De(1,n))}:function(t,e,n){return t[e]=n,t},Me=te,Ge=Yt("keys"),Be=function(t){return Ge[t]||(Ge[t]=Me(t))},Ue={},We=q,ze=I,He=J,Ve=Fe,Ke=m,qe=M,Xe=Be,Ye=Ue,Je="Object already initialized",$e=ze.TypeError,Qe=ze.WeakMap;if(We||qe.state){var Ze=qe.state||(qe.state=new Qe);Ze.get=Ze.get,Ze.has=Ze.has,Ze.set=Ze.set,Ce=function(t,e){if(Ze.has(t))throw new $e(Je);return e.facade=t,Ze.set(t,e),e},Ie=function(t){return Ze.get(t)||{}},ke=function(t){return Ze.has(t)}}else{var tn=Xe("state");Ye[tn]=!0,Ce=function(t,e){if(Ke(t,tn))throw new $e(Je);return e.facade=t,Ve(t,tn,e),e},Ie=function(t){return Ke(t,tn)?t[tn]:{}},ke=function(t){return Ke(t,tn)}}var en={set:Ce,get:Ie,has:ke,enforce:function(t){return ke(t)?Ie(t):Ce(t,{})},getterFor:function(t){return function(e){var n;if(!He(e)||(n=Ie(e)).type!==t)throw new $e("Incompatible receiver, "+t+" required");return n}}},nn=f,rn=n,on=L,un=m,cn=r,an=E.CONFIGURABLE,fn=H,sn=en.enforce,ln=en.get,pn=String,hn=Object.defineProperty,vn=nn("".slice),dn=nn("".replace),yn=nn([].join),gn=cn&&!rn((function(){return 8!==hn((function(){}),"length",{value:8}).length})),bn=String(String).split("String"),mn=P.exports=function(t,e,n){"Symbol("===vn(pn(e),0,7)&&(e="["+dn(pn(e),/^Symbol\(([^)]*)\)/,"$1")+"]"),n&&n.getter&&(e="get "+e),n&&n.setter&&(e="set "+e),(!un(t,"name")||an&&t.name!==e)&&(cn?hn(t,"name",{value:e,configurable:!0}):t.name=e),gn&&n&&un(n,"arity")&&t.length!==n.arity&&hn(t,"length",{value:n.arity});try{n&&un(n,"constructor")&&n.constructor?cn&&hn(t,"prototype",{writable:!1}):t.prototype&&(t.prototype=void 0)}catch(t){}var r=sn(t);return un(r,"source")||(r.source=yn(bn,"string"==typeof e?e:"")),t};Function.prototype.toString=mn((function(){return on(this)&&ln(this).source||fn(this)}),"toString");var wn=P.exports,On=wn,Sn=$,jn=function(t,e,n){return n.get&&On(n.get,e,{getter:!0}),n.set&&On(n.set,e,{setter:!0}),Sn.f(t,e,n)},Tn=r,En=E.EXISTS,Pn=f,xn=jn,An=Function.prototype,Rn=Pn(An.toString),Ln=/function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/,Cn=Pn(Ln.exec);Tn&&!En&&xn(An,"name",{configurable:!0,get:function(){try{return Cn(Ln,Rn(this))[1]}catch(t){return""}}});var In={},kn={},_n={}.propertyIsEnumerable,Nn=Object.getOwnPropertyDescriptor,Dn=Nn&&!_n.call({1:2},1);kn.f=Dn?function(t){var e=Nn(this,t);return!!e&&e.enumerable}:_n;var Fn=f,Mn=Fn({}.toString),Gn=Fn("".slice),Bn=function(t){return Gn(Mn(t),8,-1)},Un=n,Wn=Bn,zn=Object,Hn=f("".split),Vn=Un((function(){return!zn("z").propertyIsEnumerable(0)}))?function(t){return"String"===Wn(t)?Hn(t,""):zn(t)}:zn,Kn=Vn,qn=h,Xn=function(t){return Kn(qn(t))},Yn=r,Jn=lt,$n=kn,Qn=_e,Zn=Xn,tr=me,er=m,nr=rt,rr=Object.getOwnPropertyDescriptor;In.f=Yn?rr:function(t,e){if(t=Zn(t),e=tr(e),nr)try{return rr(t,e)}catch(t){}if(er(t,e))return Qn(!Jn($n.f,t,e),t[e])};var or=L,ir=$,ur=wn,cr=N,ar=function(t,e,n,r){r||(r={});var o=r.enumerable,i=void 0!==r.name?r.name:e;if(or(n)&&ur(n,i,r),r.global)o?t[e]=n:cr(e,n);else{try{r.unsafe?t[e]&&(o=!0):delete t[e]}catch(t){}o?t[e]=n:ir.f(t,e,{value:n,enumerable:!1,configurable:!r.nonConfigurable,writable:!r.nonWritable})}return t},fr={},sr=Math.ceil,lr=Math.floor,pr=Math.trunc||function(t){var e=+t;return(e>0?lr:sr)(e)},hr=function(t){var e=+t;return e!=e||0===e?0:pr(e)},vr=hr,dr=Math.max,yr=Math.min,gr=function(t,e){var n=vr(t);return n<0?dr(n+e,0):yr(n,e)},br=hr,mr=Math.min,wr=function(t){return t>0?mr(br(t),9007199254740991):0},Or=function(t){return wr(t.length)},Sr=Xn,jr=gr,Tr=Or,Er=function(t){return function(e,n,r){var o,i=Sr(e),u=Tr(i),c=jr(r,u);if(t&&n!=n){for(;u>c;)if((o=i[c++])!=o)return!0}else for(;u>c;c++)if((t||c in i)&&i[c]===n)return t||c||0;return!t&&-1}},Pr={includes:Er(!0),indexOf:Er(!1)},xr=m,Ar=Xn,Rr=Pr.indexOf,Lr=Ue,Cr=f([].push),Ir=function(t,e){var n,r=Ar(t),o=0,i=[];for(n in r)!xr(Lr,n)&&xr(r,n)&&Cr(i,n);for(;e.length>o;)xr(r,n=e[o++])&&(~Rr(i,n)||Cr(i,n));return i},kr=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],_r=Ir,Nr=kr.concat("length","prototype");fr.f=Object.getOwnPropertyNames||function(t){return _r(t,Nr)};var Dr={};Dr.f=Object.getOwnPropertySymbols;var Fr=vt,Mr=fr,Gr=Dr,Br=at,Ur=f([].concat),Wr=Fr("Reflect","ownKeys")||function(t){var e=Mr.f(Br(t)),n=Gr.f;return n?Ur(e,n(t)):e},zr=m,Hr=Wr,Vr=In,Kr=$,qr=n,Xr=L,Yr=/#|\.prototype\./,Jr=function(t,e){var n=Qr[$r(t)];return n===to||n!==Zr&&(Xr(e)?qr(e):!!e)},$r=Jr.normalize=function(t){return String(t).replace(Yr,".").toLowerCase()},Qr=Jr.data={},Zr=Jr.NATIVE="N",to=Jr.POLYFILL="P",eo=Jr,no=I,ro=In.f,oo=Fe,io=ar,uo=N,co=function(t,e,n){for(var r=Hr(e),o=Kr.f,i=Vr.f,u=0;uo;)for(var c,a=So(arguments[o++]),f=i?Eo(bo(a),i(a)):bo(a),s=f.length,l=0;s>l;)c=f[l++],ho&&!yo(u,a,c)||(n[c]=a[c]);return n}:jo,xo=Po;fo({target:"Object",stat:!0,arity:2,forced:Object.assign!==xo},{assign:xo});var Ao={};Ao[fe("toStringTag")]="z";var Ro="[object z]"===String(Ao),Lo=Ro,Co=L,Io=Bn,ko=fe("toStringTag"),_o=Object,No="Arguments"===Io(function(){return arguments}()),Do=Lo?Io:function(t){var e,n,r;return void 0===t?"Undefined":null===t?"Null":"string"==typeof(n=function(t,e){try{return t[e]}catch(t){}}(e=_o(t),ko))?n:No?Io(e):"Object"===(r=Io(e))&&Co(e.callee)?"Arguments":r},Fo=Do,Mo=Ro?{}.toString:function(){return"[object "+Fo(this)+"]"};Ro||ar(Object.prototype,"toString",Mo,{unsafe:!0});var Go="process"===Bn(I.process),Bo=f,Uo=Gt,Wo=L,zo=String,Ho=TypeError,Vo=function(t,e,n){try{return Bo(Uo(Object.getOwnPropertyDescriptor(t,e)[n]))}catch(t){}},Ko=at,qo=function(t){if("object"==typeof t||Wo(t))return t;throw new Ho("Can't set "+zo(t)+" as a prototype")},Xo=Object.setPrototypeOf||("__proto__"in{}?function(){var t,e=!1,n={};try{(t=Vo(Object.prototype,"__proto__","set"))(n,[]),e=n instanceof Array}catch(t){}return function(n,r){return Ko(n),qo(r),e?t(n,r):n.__proto__=r,n}}():void 0),Yo=$.f,Jo=m,$o=fe("toStringTag"),Qo=function(t,e,n){t&&!n&&(t=t.prototype),t&&!Jo(t,$o)&&Yo(t,$o,{configurable:!0,value:e})},Zo=vt,ti=jn,ei=r,ni=fe("species"),ri=dt,oi=TypeError,ii=function(t,e){if(ri(e,t))return t;throw new oi("Incorrect invocation")},ui=f,ci=n,ai=L,fi=Do,si=H,li=function(){},pi=[],hi=vt("Reflect","construct"),vi=/^\s*(?:class|function)\b/,di=ui(vi.exec),yi=!vi.test(li),gi=function(t){if(!ai(t))return!1;try{return hi(li,pi,t),!0}catch(t){return!1}},bi=function(t){if(!ai(t))return!1;switch(fi(t)){case"AsyncFunction":case"GeneratorFunction":case"AsyncGeneratorFunction":return!1}try{return yi||!!di(vi,si(t))}catch(t){return!0}};bi.sham=!0;var mi,wi,Oi,Si,ji=!hi||ci((function(){var t;return gi(gi.call)||!gi(Object)||!gi((function(){t=!0}))||t}))?bi:gi,Ti=ji,Ei=Nt,Pi=TypeError,xi=at,Ai=function(t){if(Ti(t))return t;throw new Pi(Ei(t)+" is not a constructor")},Ri=s,Li=fe("species"),Ci=o,Ii=Function.prototype,ki=Ii.apply,_i=Ii.call,Ni="object"==typeof Reflect&&Reflect.apply||(Ci?_i.bind(ki):function(){return _i.apply(ki,arguments)}),Di=Bn,Fi=f,Mi=function(t){if("Function"===Di(t))return Fi(t)},Gi=Gt,Bi=o,Ui=Mi(Mi.bind),Wi=function(t,e){return Gi(t),void 0===e?t:Bi?Ui(t,e):function(){return t.apply(e,arguments)}},zi=vt("document","documentElement"),Hi=f([].slice),Vi=TypeError,Ki=/(?:ipad|iphone|ipod).*applewebkit/i.test(yt),qi=I,Xi=Ni,Yi=Wi,Ji=L,$i=m,Qi=n,Zi=zi,tu=Hi,eu=et,nu=function(t,e){if(ti;i++)if((c=g(t[i]))&&Da(Wa,c))return c;return new Ua(!1)}r=Fa(t,o)}for(a=p?t.next:r.next;!(f=Ca(a,r)).done;){try{c=g(f.value)}catch(t){Ga(r,"throw",t)}if("object"==typeof c&&c&&Da(Wa,c))return c}return new Ua(!1)},Ha=fe("iterator"),Va=!1;try{var Ka=0,qa={next:function(){return{done:!!Ka++}},return:function(){Va=!0}};qa[Ha]=function(){return this},Array.from(qa,(function(){throw 2}))}catch(t){}var Xa=function(t,e){try{if(!e&&!Va)return!1}catch(t){return!1}var n=!1;try{var r={};r[Ha]=function(){return{next:function(){return{done:n=!0}}}},t(r)}catch(t){}return n},Ya=Xu,Ja=sc.CONSTRUCTOR||!Xa((function(t){Ya.all(t).then(void 0,(function(){}))})),$a=lt,Qa=Gt,Za=lc,tf=qu,ef=za;fo({target:"Promise",stat:!0,forced:Ja},{all:function(t){var e=this,n=Za.f(e),r=n.resolve,o=n.reject,i=tf((function(){var n=Qa(e.resolve),i=[],u=0,c=1;ef(t,(function(t){var a=u++,f=!1;c++,$a(n,e,t).then((function(t){f||(f=!0,i[a]=t,--c||r(i))}),o)})),--c||r(i)}));return i.error&&o(i.value),n.promise}});var nf=fo,rf=sc.CONSTRUCTOR,of=Xu,uf=vt,cf=L,af=ar,ff=of&&of.prototype;if(nf({target:"Promise",proto:!0,forced:rf,real:!0},{catch:function(t){return this.then(void 0,t)}}),cf(of)){var sf=uf("Promise").prototype.catch;ff.catch!==sf&&af(ff,"catch",sf,{unsafe:!0})}var lf=lt,pf=Gt,hf=lc,vf=qu,df=za;fo({target:"Promise",stat:!0,forced:Ja},{race:function(t){var e=this,n=hf.f(e),r=n.reject,o=vf((function(){var o=pf(e.resolve);df(t,(function(t){lf(o,e,t).then(n.resolve,r)}))}));return o.error&&r(o.value),n.promise}});var yf=lt,gf=lc;fo({target:"Promise",stat:!0,forced:sc.CONSTRUCTOR},{reject:function(t){var e=gf.f(this);return yf(e.reject,void 0,t),e.promise}});var bf=at,mf=J,wf=lc,Of=fo,Sf=sc.CONSTRUCTOR,jf=function(t,e){if(bf(t),mf(e)&&e.constructor===t)return e;var n=wf.f(t);return(0,n.resolve)(e),n.promise};vt("Promise"),Of({target:"Promise",stat:!0,forced:Sf},{resolve:function(t){return jf(this,t)}});var Tf=n,Ef=function(t,e){var n=[][t];return!!n&&Tf((function(){n.call(null,e||function(){return 1},1)}))},Pf=fo,xf=Vn,Af=Xn,Rf=Ef,Lf=f([].join);Pf({target:"Array",proto:!0,forced:xf!==Object||!Rf("join",",")},{join:function(t){return Lf(Af(this),void 0===t?",":t)}});var Cf={},If=r,kf=ot,_f=$,Nf=at,Df=Xn,Ff=po;Cf.f=If&&!kf?Object.defineProperties:function(t,e){Nf(t);for(var n,r=Df(e),o=Ff(e),i=o.length,u=0;i>u;)_f.f(t,n=o[u++],r[n]);return t};var Mf,Gf=at,Bf=Cf,Uf=kr,Wf=Ue,zf=zi,Hf=et,Vf="prototype",Kf="script",qf=Be("IE_PROTO"),Xf=function(){},Yf=function(t){return"<"+Kf+">"+t+""},Jf=function(t){t.write(Yf("")),t.close();var e=t.parentWindow.Object;return t=null,e},$f=function(){try{Mf=new ActiveXObject("htmlfile")}catch(t){}var t,e,n;$f="undefined"!=typeof document?document.domain&&Mf?Jf(Mf):(e=Hf("iframe"),n="java"+Kf+":",e.style.display="none",zf.appendChild(e),e.src=String(n),(t=e.contentWindow.document).open(),t.write(Yf("document.F=Object")),t.close(),t.F):Jf(Mf);for(var r=Uf.length;r--;)delete $f[Vf][Uf[r]];return $f()};Wf[qf]=!0;var Qf=Object.create||function(t,e){var n;return null!==t?(Xf[Vf]=Gf(t),n=new Xf,Xf[Vf]=null,n[qf]=t):n=$f(),void 0===e?n:Bf.f(n,e)},Zf=fe,ts=Qf,es=$.f,ns=Zf("unscopables"),rs=Array.prototype;void 0===rs[ns]&&es(rs,ns,{configurable:!0,value:ts(null)});var os,is,us,cs=!n((function(){function t(){}return t.prototype.constructor=null,Object.getPrototypeOf(new t)!==t.prototype})),as=m,fs=L,ss=y,ls=cs,ps=Be("IE_PROTO"),hs=Object,vs=hs.prototype,ds=ls?hs.getPrototypeOf:function(t){var e=ss(t);if(as(e,ps))return e[ps];var n=e.constructor;return fs(n)&&e instanceof n?n.prototype:e instanceof hs?vs:null},ys=n,gs=L,bs=J,ms=ds,ws=ar,Os=fe("iterator"),Ss=!1;[].keys&&("next"in(us=[].keys())?(is=ms(ms(us)))!==Object.prototype&&(os=is):Ss=!0);var js=!bs(os)||ys((function(){var t={};return os[Os].call(t)!==t}));js&&(os={}),gs(os[Os])||ws(os,Os,(function(){return this}));var Ts={IteratorPrototype:os,BUGGY_SAFARI_ITERATORS:Ss},Es=Ts.IteratorPrototype,Ps=Qf,xs=_e,As=Qo,Rs=la,Ls=function(){return this},Cs=fo,Is=lt,ks=L,_s=function(t,e,n,r){var o=e+" Iterator";return t.prototype=Ps(Es,{next:xs(+!r,n)}),As(t,o,!1),Rs[o]=Ls,t},Ns=ds,Ds=Xo,Fs=Qo,Ms=Fe,Gs=ar,Bs=la,Us=E.PROPER,Ws=E.CONFIGURABLE,zs=Ts.IteratorPrototype,Hs=Ts.BUGGY_SAFARI_ITERATORS,Vs=fe("iterator"),Ks="keys",qs="values",Xs="entries",Ys=function(){return this},Js=function(t,e,n,r,o,i,u){_s(n,e,r);var c,a,f,s=function(t){if(t===o&&d)return d;if(!Hs&&t&&t in h)return h[t];switch(t){case Ks:case qs:case Xs:return function(){return new n(this,t)}}return function(){return new n(this)}},l=e+" Iterator",p=!1,h=t.prototype,v=h[Vs]||h["@@iterator"]||o&&h[o],d=!Hs&&v||s(o),y="Array"===e&&h.entries||v;if(y&&(c=Ns(y.call(new t)))!==Object.prototype&&c.next&&(Ns(c)!==zs&&(Ds?Ds(c,zs):ks(c[Vs])||Gs(c,Vs,Ys)),Fs(c,l,!0)),Us&&o===qs&&v&&v.name!==qs&&(Ws?Ms(h,"name",qs):(p=!0,d=function(){return Is(v,this)})),o)if(a={values:s(qs),keys:i?d:s(Ks),entries:s(Xs)},u)for(f in a)(Hs||p||!(f in h))&&Gs(h,f,a[f]);else Cs({target:e,proto:!0,forced:Hs||p},a);return h[Vs]!==d&&Gs(h,Vs,d,{name:o}),Bs[e]=d,a},$s=function(t,e){return{value:t,done:e}},Qs=Xn,Zs=function(t){rs[ns][t]=!0},tl=la,el=en,nl=$.f,rl=Js,ol=$s,il=r,ul="Array Iterator",cl=el.set,al=el.getterFor(ul),fl=rl(Array,"Array",(function(t,e){cl(this,{type:ul,target:Qs(t),index:0,kind:e})}),(function(){var t=al(this),e=t.target,n=t.index++;if(!e||n>=e.length)return t.target=void 0,ol(void 0,!0);switch(t.kind){case"keys":return ol(n,!1);case"values":return ol(e[n],!1)}return ol([n,e[n]],!1)}),"values"),sl=tl.Arguments=tl.Array;if(Zs("keys"),Zs("values"),Zs("entries"),il&&"values"!==sl.name)try{nl(sl,"name",{value:"values"})}catch(t){}var ll=Do,pl=String,hl=function(t){if("Symbol"===ll(t))throw new TypeError("Cannot convert a Symbol value to a string");return pl(t)},vl=f,dl=hr,yl=hl,gl=h,bl=vl("".charAt),ml=vl("".charCodeAt),wl=vl("".slice),Ol=function(t){return function(e,n){var r,o,i=yl(gl(e)),u=dl(n),c=i.length;return u<0||u>=c?t?"":void 0:(r=ml(i,u))<55296||r>56319||u+1===c||(o=ml(i,u+1))<56320||o>57343?t?bl(i,u):r:t?wl(i,u,u+2):o-56320+(r-55296<<10)+65536}},Sl={codeAt:Ol(!1),charAt:Ol(!0)}.charAt,jl=hl,Tl=en,El=Js,Pl=$s,xl="String Iterator",Al=Tl.set,Rl=Tl.getterFor(xl);El(String,"String",(function(t){Al(this,{type:xl,string:jl(t),index:0})}),(function(){var t,e=Rl(this),n=e.string,r=e.index;return r>=n.length?Pl(void 0,!0):(t=Sl(n,r),e.index+=t.length,Pl(t,!1))}));var Ll={exports:{}},Cl={},Il=me,kl=$,_l=_e,Nl=gr,Dl=Or,Fl=function(t,e,n){var r=Il(e);r in t?kl.f(t,r,_l(0,n)):t[r]=n},Ml=Array,Gl=Math.max,Bl=Bn,Ul=Xn,Wl=fr.f,zl=function(t,e,n){for(var r=Dl(t),o=Nl(e,r),i=Nl(void 0===n?r:n,r),u=Ml(Gl(i-o,0)),c=0;ob;b++)if((c||b in d)&&(h=g(p=d[b],b,v),t))if(e)w[b]=h;else if(h)switch(t){case 3:return!0;case 5:return p;case 6:return b;case 2:Kp(w,p)}else switch(t){case 4:return!1;case 7:Kp(w,p)}return i?-1:r||o?o:w}},Xp={forEach:qp(0),map:qp(1),filter:qp(2),some:qp(3),every:qp(4),find:qp(5),findIndex:qp(6),filterReject:qp(7)},Yp=f,Jp=function(t,e,n){for(var r in e)kp(t,r,e[r],n);return t},$p=vp.getWeakData,Qp=ii,Zp=at,th=s,eh=J,nh=za,rh=m,oh=en.set,ih=en.getterFor,uh=Xp.find,ch=Xp.findIndex,ah=Yp([].splice),fh=0,sh=function(t){return t.frozen||(t.frozen=new lh)},lh=function(){this.entries=[]},ph=function(t,e){return uh(t.entries,(function(t){return t[0]===e}))};lh.prototype={get:function(t){var e=ph(this,t);if(e)return e[1]},has:function(t){return!!ph(this,t)},set:function(t,e){var n=ph(this,t);n?n[1]=e:this.entries.push([t,e])},delete:function(t){var e=ch(this.entries,(function(e){return e[0]===t}));return~e&&ah(this.entries,e,1),!!~e}};var hh={getConstructor:function(t,e,n,r){var o=t((function(t,o){Qp(t,i),oh(t,{type:e,id:fh++,frozen:void 0}),th(o)||nh(o,t[r],{that:t,AS_ENTRIES:n})})),i=o.prototype,u=ih(e),c=function(t,e,n){var r=u(t),o=$p(Zp(e),!0);return!0===o?sh(r).set(e,n):o[r.id]=n,t};return Jp(i,{delete:function(t){var e=u(this);if(!eh(t))return!1;var n=$p(t);return!0===n?sh(e).delete(t):n&&rh(n,e.id)&&delete n[e.id]},has:function(t){var e=u(this);if(!eh(t))return!1;var n=$p(t);return!0===n?sh(e).has(t):n&&rh(n,e.id)}}),Jp(i,n?{get:function(t){var e=u(this);if(eh(t)){var n=$p(t);return!0===n?sh(e).get(t):n?n[e.id]:void 0}},set:function(t,e){return c(this,t,e)}}:{add:function(t){return c(this,t,!0)}}),o}};(function(t,e,n){var r=-1!==t.indexOf("Map"),o=-1!==t.indexOf("Weak"),i=r?"set":"add",u=mp[t],c=u&&u.prototype,a=u,f={},s=function(t){var e=wp(c[t]);Sp(c,t,"add"===t?function(t){return e(this,0===t?0:t),this}:"delete"===t?function(t){return!(o&&!Ap(t))&&e(this,0===t?0:t)}:"get"===t?function(t){return o&&!Ap(t)?void 0:e(this,0===t?0:t)}:"has"===t?function(t){return!(o&&!Ap(t))&&e(this,0===t?0:t)}:function(t,n){return e(this,0===t?0:t,n),this})};if(Op(t,!Pp(u)||!(o||c.forEach&&!Rp((function(){(new u).entries().next()})))))a=n.getConstructor(e,t,r,i),jp.enable();else if(Op(t,!0)){var l=new a,p=l[i](o?{}:-0,1)!==l,h=Rp((function(){l.has(1)})),v=Lp((function(t){new u(t)})),d=!o&&Rp((function(){for(var t=new u,e=5;e--;)t[i](e,e);return!t.has(-0)}));v||((a=e((function(t,e){Ep(t,c);var n=Ip(new u,t,a);return xp(e)||Tp(e,n[i],{that:n,AS_ENTRIES:r}),n}))).prototype=c,c.constructor=a),(h||d)&&(s("delete"),s("has"),r&&s("get")),(d||p)&&s(i),o&&c.clear&&delete c.clear}f[t]=a,bp({global:!0,constructor:!0,forced:a!==u},f),Cp(a,t),o||n.setStrong(a,t,r)})("WeakSet",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),hh);var vh={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0},dh=et("span").classList,yh=dh&&dh.constructor&&dh.constructor.prototype,gh=yh===Object.prototype?void 0:yh,bh=I,mh=vh,wh=gh,Oh=fl,Sh=Fe,jh=Qo,Th=fe("iterator"),Eh=Oh.values,Ph=function(t,e){if(t){if(t[Th]!==Eh)try{Sh(t,Th,Eh)}catch(e){t[Th]=Eh}if(jh(t,e,!0),mh[e])for(var n in Oh)if(t[n]!==Oh[n])try{Sh(t,n,Oh[n])}catch(e){t[n]=Oh[n]}}};for(var xh in mh)Ph(bh[xh]&&bh[xh].prototype,xh);Ph(wh,"DOMTokenList");var Ah=Xp.forEach,Rh=I,Lh=vh,Ch=gh,Ih=Ef("forEach")?[].forEach:function(t){return Ah(this,t,arguments.length>1?arguments[1]:void 0)},kh=Fe,_h=function(t){if(t&&t.forEach!==Ih)try{kh(t,"forEach",Ih)}catch(e){t.forEach=Ih}};for(var Nh in Lh)Lh[Nh]&&_h(Rh[Nh]&&Rh[Nh].prototype);_h(Ch);var Dh,Fh,Mh,Gh,Bh,Uh,Wh,zh,Hh,Vh,Kh=y,qh=po;function Xh(t,e,n,r){if("a"===n&&!r)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof e?t!==e||!r:!e.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===n?r:"a"===n?r.call(t):r?r.value:e.get(t)}function Yh(t){return"top"===t||"bottom"===t}function Jh(t){return t[Fh.LEFT]+t[Fh.RIGHT]}function $h(t){return t[Fh.TOP]+t[Fh.BOTTOM]}fo({target:"Object",stat:!0,forced:n((function(){qh(1)}))},{keys:function(t){return qh(Kh(t))}}),function(t){t[t.SCROLL_NONE=0]="SCROLL_NONE",t[t.SCROLL_BACKWARD=1]="SCROLL_BACKWARD",t[t.SCROLL_FORWARD=2]="SCROLL_FORWARD"}(Dh||(Dh={})),function(t){t[t.TOP=0]="TOP",t[t.RIGHT=1]="RIGHT",t[t.BOTTOM=2]="BOTTOM",t[t.LEFT=3]="LEFT"}(Fh||(Fh={}));var Qh=".ch-plugin-calendar-label",Zh={enabled:!0,dimensions:{width:0,height:0},position:"left",text:function(){return[]},padding:[0,0,0,0]},tv=function(){function e(t){var n,r;!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,e),Mh.add(this),this.name="CalendarLabel";var o=null===(r=null===(n=null==t?void 0:t.options)||void 0===n?void 0:n.options)||void 0===r?void 0:r.subDomain;this.calendar=t,this.root=null,this.shown=!1,this.options=Zh,this.computedOptions={radius:null==o?void 0:o.radius,width:null==o?void 0:o.width,height:null==o?void 0:o.height,gutter:null==o?void 0:o.gutter,textAlign:"start"}}var n,r,o;return n=e,(r=[{key:"setup",value:function(t){this.options=Object.assign(Object.assign({},Zh),t)}},{key:"paint",value:function(){if(!this.options.enabled)return this.destroy();this.shown=!0;var t=this.calendar.calendarPainter.root;return this.root||(this.root=t.append("svg").attr("class",Qh.slice(1)).attr("data-key",this.options.key).attr("x",0).attr("y",0)),this.build(),Promise.resolve()}},{key:"destroy",value:function(){return null!==this.root&&(this.root.remove(),this.root=null),Promise.resolve()}},{key:"build",value:function(){var t=this;return Xh(this,Mh,"m",Gh).call(this),Xh(this,Mh,"m",Bh).call(this),this.root.selectAll("g").data(this.options.text).join((function(e){return e.append("g").call((function(e){return e.append("rect").attr("class","".concat(Qh.slice(1),"-bg")).attr("style","fill: transparent").call((function(e){return Xh(t,Mh,"m",Uh).call(t,e)}))})).call((function(e){return e.append("text").attr("class","".concat(Qh.slice(1),"-text")).attr("dominant-baseline","central").attr("text-anchor","middle").attr("style","fill: currentColor; font-size: 10px").call((function(e){return Xh(t,Mh,"m",Wh).call(t,e)}))}))})),Promise.resolve()}}])&&t(n.prototype,r),o&&t(n,o),Object.defineProperty(n,"prototype",{writable:!1}),e}();Mh=new WeakSet,Gh=function(){var t=this;Object.keys(this.computedOptions).forEach((function(e){void 0!==t.options[e]&&(t.computedOptions[e]=t.options[e])}))},Bh=function(){var t=this.computedOptions,e=t.width,n=t.height,r=t.gutter,o=this.options,i=o.text,u=o.padding,c=o.position,a=i().length;this.options.dimensions={width:e+Jh(u),height:n+$h(u)},Yh(c)?this.options.dimensions.width+=(e+r)*(a-1):this.options.dimensions.height+=(n+r)*(a-1)},Uh=function(t){var e=this,n=this.computedOptions,r=n.width,o=n.height,i=n.radius;t.attr("width",r).attr("height",o).attr("rx",i&&i>0?i:null).attr("ry",i&&i>0?i:null).attr("x",(function(t,n){return Xh(e,Mh,"m",Hh).call(e,n)})).attr("y",(function(t,n){return Xh(e,Mh,"m",Vh).call(e,n)}))},Wh=function(t){var e=this,n=this.computedOptions,r=n.height,o=n.textAlign;t.attr("text-anchor",o).attr("x",(function(t,n){return Xh(e,Mh,"m",zh).call(e)+Xh(e,Mh,"m",Hh).call(e,n)})).attr("y",(function(t,n){return Xh(e,Mh,"m",Vh).call(e,n)+r/2})).text((function(t){return t}))},zh=function(){var t=this.computedOptions,e=t.width;switch(t.textAlign){case"start":default:return 0;case"middle":return e/2;case"end":return e}},Hh=function(t){var e=this.options,n=e.position,r=e.padding,o=this.computedOptions,i=o.width,u=o.gutter;return function(t){return"left"===t||"right"===t}(n)?r[Fh.LEFT]:r[Fh.LEFT]+(i+u)*t},Vh=function(t){var e=this.options,n=e.position,r=e.padding,o=this.computedOptions,i=o.height,u=o.gutter;return Yh(n)?r[Fh.TOP]:r[Fh.TOP]+(i+u)*t};export{tv as default};//# sourceMappingURL=CalendarLabel.min.esm.js.map diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.esm.js.map b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.esm.js.map new file mode 100644 index 0000000..9b21a60 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.esm.js.map @@ -0,0 +1 @@ +{"version":3,"file":"CalendarLabel.min.esm.js","sources":["../../node_modules/core-js/internals/fails.js","../../node_modules/core-js/internals/descriptors.js","../../node_modules/core-js/internals/function-bind-native.js","../../node_modules/core-js/internals/function-uncurry-this.js","../../node_modules/core-js/internals/is-null-or-undefined.js","../../node_modules/core-js/internals/require-object-coercible.js","../../node_modules/core-js/internals/to-object.js","../../node_modules/core-js/internals/has-own-property.js","../../node_modules/core-js/internals/function-name.js","../../node_modules/core-js/internals/document-all.js","../../node_modules/core-js/internals/is-callable.js","../../node_modules/core-js/internals/global.js","../../node_modules/core-js/internals/define-global-property.js","../../node_modules/core-js/internals/shared-store.js","../../node_modules/core-js/internals/inspect-source.js","../../node_modules/core-js/internals/engine-v8-version.js","../../node_modules/core-js/internals/weak-map-basic-detection.js","../../node_modules/core-js/internals/is-object.js","../../node_modules/core-js/internals/document-create-element.js","../../node_modules/core-js/internals/ie8-dom-define.js","../../node_modules/core-js/internals/v8-prototype-define-bug.js","../../node_modules/core-js/internals/an-object.js","../../node_modules/core-js/internals/function-call.js","../../node_modules/core-js/internals/get-built-in.js","../../node_modules/core-js/internals/object-is-prototype-of.js","../../node_modules/core-js/internals/engine-user-agent.js","../../node_modules/core-js/internals/symbol-constructor-detection.js","../../node_modules/core-js/internals/use-symbol-as-uid.js","../../node_modules/core-js/internals/is-symbol.js","../../node_modules/core-js/internals/try-to-string.js","../../node_modules/core-js/internals/a-callable.js","../../node_modules/core-js/internals/get-method.js","../../node_modules/core-js/internals/ordinary-to-primitive.js","../../node_modules/core-js/internals/shared.js","../../node_modules/core-js/internals/uid.js","../../node_modules/core-js/internals/well-known-symbol.js","../../node_modules/core-js/internals/to-primitive.js","../../node_modules/core-js/internals/to-property-key.js","../../node_modules/core-js/internals/object-define-property.js","../../node_modules/core-js/internals/create-property-descriptor.js","../../node_modules/core-js/internals/internal-state.js","../../node_modules/core-js/internals/create-non-enumerable-property.js","../../node_modules/core-js/internals/shared-key.js","../../node_modules/core-js/internals/hidden-keys.js","../../node_modules/core-js/internals/make-built-in.js","../../node_modules/core-js/internals/define-built-in-accessor.js","../../node_modules/core-js/modules/es.function.name.js","../../node_modules/core-js/internals/object-property-is-enumerable.js","../../node_modules/core-js/internals/classof-raw.js","../../node_modules/core-js/internals/indexed-object.js","../../node_modules/core-js/internals/to-indexed-object.js","../../node_modules/core-js/internals/object-get-own-property-descriptor.js","../../node_modules/core-js/internals/define-built-in.js","../../node_modules/core-js/internals/math-trunc.js","../../node_modules/core-js/internals/to-integer-or-infinity.js","../../node_modules/core-js/internals/to-absolute-index.js","../../node_modules/core-js/internals/to-length.js","../../node_modules/core-js/internals/length-of-array-like.js","../../node_modules/core-js/internals/array-includes.js","../../node_modules/core-js/internals/object-keys-internal.js","../../node_modules/core-js/internals/enum-bug-keys.js","../../node_modules/core-js/internals/object-get-own-property-names.js","../../node_modules/core-js/internals/object-get-own-property-symbols.js","../../node_modules/core-js/internals/own-keys.js","../../node_modules/core-js/internals/copy-constructor-properties.js","../../node_modules/core-js/internals/is-forced.js","../../node_modules/core-js/internals/export.js","../../node_modules/core-js/internals/object-keys.js","../../node_modules/core-js/internals/object-assign.js","../../node_modules/core-js/modules/es.object.assign.js","../../node_modules/core-js/internals/to-string-tag-support.js","../../node_modules/core-js/internals/classof.js","../../node_modules/core-js/internals/object-to-string.js","../../node_modules/core-js/modules/es.object.to-string.js","../../node_modules/core-js/internals/engine-is-node.js","../../node_modules/core-js/internals/function-uncurry-this-accessor.js","../../node_modules/core-js/internals/a-possible-prototype.js","../../node_modules/core-js/internals/object-set-prototype-of.js","../../node_modules/core-js/internals/set-to-string-tag.js","../../node_modules/core-js/internals/set-species.js","../../node_modules/core-js/internals/an-instance.js","../../node_modules/core-js/internals/is-constructor.js","../../node_modules/core-js/internals/task.js","../../node_modules/core-js/internals/a-constructor.js","../../node_modules/core-js/internals/species-constructor.js","../../node_modules/core-js/internals/function-apply.js","../../node_modules/core-js/internals/function-uncurry-this-clause.js","../../node_modules/core-js/internals/function-bind-context.js","../../node_modules/core-js/internals/html.js","../../node_modules/core-js/internals/array-slice.js","../../node_modules/core-js/internals/validate-arguments-length.js","../../node_modules/core-js/internals/engine-is-ios.js","../../node_modules/core-js/internals/queue.js","../../node_modules/core-js/internals/microtask.js","../../node_modules/core-js/internals/engine-is-ios-pebble.js","../../node_modules/core-js/internals/engine-is-webos-webkit.js","../../node_modules/core-js/internals/perform.js","../../node_modules/core-js/internals/promise-native-constructor.js","../../node_modules/core-js/internals/engine-is-deno.js","../../node_modules/core-js/internals/engine-is-browser.js","../../node_modules/core-js/internals/promise-constructor-detection.js","../../node_modules/core-js/internals/new-promise-capability.js","../../node_modules/core-js/modules/es.promise.constructor.js","../../node_modules/core-js/internals/host-report-errors.js","../../node_modules/core-js/internals/iterators.js","../../node_modules/core-js/internals/is-array-iterator-method.js","../../node_modules/core-js/internals/get-iterator-method.js","../../node_modules/core-js/internals/get-iterator.js","../../node_modules/core-js/internals/iterator-close.js","../../node_modules/core-js/internals/iterate.js","../../node_modules/core-js/internals/check-correctness-of-iteration.js","../../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","../../node_modules/core-js/modules/es.promise.all.js","../../node_modules/core-js/modules/es.promise.catch.js","../../node_modules/core-js/modules/es.promise.race.js","../../node_modules/core-js/modules/es.promise.reject.js","../../node_modules/core-js/internals/promise-resolve.js","../../node_modules/core-js/modules/es.promise.resolve.js","../../node_modules/core-js/internals/array-method-is-strict.js","../../node_modules/core-js/modules/es.array.join.js","../../node_modules/core-js/internals/object-define-properties.js","../../node_modules/core-js/internals/object-create.js","../../node_modules/core-js/internals/add-to-unscopables.js","../../node_modules/core-js/internals/iterators-core.js","../../node_modules/core-js/internals/correct-prototype-getter.js","../../node_modules/core-js/internals/object-get-prototype-of.js","../../node_modules/core-js/internals/iterator-create-constructor.js","../../node_modules/core-js/internals/iterator-define.js","../../node_modules/core-js/internals/create-iter-result-object.js","../../node_modules/core-js/modules/es.array.iterator.js","../../node_modules/core-js/internals/to-string.js","../../node_modules/core-js/internals/string-multibyte.js","../../node_modules/core-js/modules/es.string.iterator.js","../../node_modules/core-js/internals/create-property.js","../../node_modules/core-js/internals/array-slice-simple.js","../../node_modules/core-js/internals/object-get-own-property-names-external.js","../../node_modules/core-js/internals/array-buffer-non-extensible.js","../../node_modules/core-js/internals/object-is-extensible.js","../../node_modules/core-js/internals/freezing.js","../../node_modules/core-js/internals/internal-metadata.js","../../node_modules/core-js/internals/inherit-if-required.js","../../node_modules/core-js/internals/collection.js","../../node_modules/core-js/internals/define-built-ins.js","../../node_modules/core-js/internals/is-array.js","../../node_modules/core-js/internals/array-species-constructor.js","../../node_modules/core-js/internals/array-species-create.js","../../node_modules/core-js/internals/array-iteration.js","../../node_modules/core-js/internals/collection-weak.js","../../node_modules/core-js/modules/es.weak-set.constructor.js","../../node_modules/core-js/internals/dom-iterables.js","../../node_modules/core-js/internals/dom-token-list-prototype.js","../../node_modules/core-js/modules/web.dom-collections.iterator.js","../../node_modules/core-js/internals/array-for-each.js","../../node_modules/core-js/modules/web.dom-collections.for-each.js","../../node_modules/core-js/modules/es.object.keys.js","../../../src/constant.ts","../../node_modules/tslib/tslib.es6.js","../../../src/helpers/PositionHelper.ts","../../../src/plugins/CalendarLabel.ts"],"sourcesContent":["'use strict';\nmodule.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-function-prototype-bind -- safe\n var test = (function () { /* empty */ }).bind();\n // eslint-disable-next-line no-prototype-builtins -- safe\n return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n return function () {\n return call.apply(fn, arguments);\n };\n};\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n return it === null || it === undefined;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n return it;\n};\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar documentAll = typeof document == 'object' && document.all;\n\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nvar IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;\n\nmodule.exports = {\n all: documentAll,\n IS_HTMLDDA: IS_HTMLDDA\n};\n","'use strict';\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = $documentAll.IS_HTMLDDA ? function (argument) {\n return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n return typeof argument == 'function';\n};\n","'use strict';\nvar check = function (it) {\n return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n check(typeof this == 'object' && this) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\nmodule.exports = $documentAll.IS_HTMLDDA ? function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;\n} : function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a !== 7;\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype !== 42;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol('symbol detection');\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n // of course, fail.\n return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n try {\n return $String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.34.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',\n license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',\n source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name)) {\n WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n ? Symbol[name]\n : createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw new $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","'use strict';\nmodule.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n /* eslint-disable no-self-assign -- prototype methods protection */\n store.get = store.get;\n store.has = store.has;\n store.set = store.set;\n /* eslint-enable no-self-assign -- prototype methods protection */\n set = function (it, metadata) {\n if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n store.set(it, metadata);\n return metadata;\n };\n get = function (it) {\n return store.get(it) || {};\n };\n has = function (it) {\n return store.has(it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (options && options.getter) name = 'get ' + name;\n if (options && options.setter) name = 'set ' + name;\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n else value.name = name;\n }\n if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n defineProperty(value, 'length', { value: options.arity });\n }\n try {\n if (options && hasOwn(options, 'constructor') && options.constructor) {\n if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n } else if (value.prototype) value.prototype = undefined;\n } catch (error) { /* empty */ }\n var state = enforceInternalState(value);\n if (!hasOwn(state, 'source')) {\n state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineProperty = require('../internals/object-define-property');\n\nmodule.exports = function (target, name, descriptor) {\n if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });\n if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });\n return defineProperty.f(target, name, descriptor);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar FUNCTION_NAME_EXISTS = require('../internals/function-name').EXISTS;\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\n\nvar FunctionPrototype = Function.prototype;\nvar functionToString = uncurryThis(FunctionPrototype.toString);\nvar nameRE = /function\\b(?:\\s|\\/\\*[\\S\\s]*?\\*\\/|\\/\\/[^\\n\\r]*[\\n\\r]+)*([^\\s(/]*)/;\nvar regExpExec = uncurryThis(nameRE.exec);\nvar NAME = 'name';\n\n// Function instances `.name` property\n// https://tc39.es/ecma262/#sec-function-instances-name\nif (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {\n defineBuiltInAccessor(FunctionPrototype, NAME, {\n configurable: true,\n get: function () {\n try {\n return regExpExec(nameRE, functionToString(this))[1];\n } catch (error) {\n return '';\n }\n }\n });\n}\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- NaN check\n return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el !== el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value !== value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value === POLYFILL ? true\n : value === NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.dontCallGetSet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || defineGlobalProperty(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.dontCallGetSet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n defineBuiltIn(target, key, sourceProperty, options);\n }\n};\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol('assign detection');\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","'use strict';\nvar $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {\n assign: assign\n});\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar global = require('../internals/global');\nvar classof = require('../internals/classof-raw');\n\nmodule.exports = classof(global.process) === 'process';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nmodule.exports = function (object, key, method) {\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));\n } catch (error) { /* empty */ }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw new $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","'use strict';\n/* eslint-disable no-proto -- safe */\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (target, TAG, STATIC) {\n if (target && !STATIC) target = target.prototype;\n if (target && !hasOwn(target, TO_STRING_TAG)) {\n defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineBuiltInAccessor(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw new $TypeError('Incorrect invocation');\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.test(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n }\n try {\n // we can't check .prototype since constructors produced by .bind haven't it\n // `Function#toString` throws on some built-it function in some legacy engines\n // (for example, `DOMQuad` and similar in FF41-)\n return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n } catch (error) {\n return true;\n }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar $location, defer, channel, port;\n\nfails(function () {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n $location = global.location;\n});\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar eventListener = function (event) {\n run(event.data);\n};\n\nvar globalPostMessageDefer = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), $location.protocol + '//' + $location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(handler) {\n validateArgumentsLength(arguments.length, 1);\n var fn = isCallable(handler) ? handler : Function(handler);\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(fn, undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = eventListener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n $location && $location.protocol !== 'file:' &&\n !fails(globalPostMessageDefer)\n ) {\n defer = globalPostMessageDefer;\n global.addEventListener('message', eventListener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","'use strict';\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a constructor');\n};\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","'use strict';\nvar classofRaw = require('../internals/classof-raw');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (fn) {\n // Nashorn bug:\n // https://github.com/zloirock/core-js/issues/1128\n // https://github.com/zloirock/core-js/issues/1130\n if (classofRaw(fn) === 'Function') return uncurryThis(fn);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","'use strict';\nvar $TypeError = TypeError;\n\nmodule.exports = function (passed, required) {\n if (passed < required) throw new $TypeError('Not enough arguments');\n return passed;\n};\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line redos/no-vulnerable -- safe\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","'use strict';\nvar Queue = function () {\n this.head = null;\n this.tail = null;\n};\n\nQueue.prototype = {\n add: function (item) {\n var entry = { item: item, next: null };\n var tail = this.tail;\n if (tail) tail.next = entry;\n else this.head = entry;\n this.tail = entry;\n },\n get: function () {\n var entry = this.head;\n if (entry) {\n var next = this.head = entry.next;\n if (next === null) this.tail = null;\n return entry.item;\n }\n }\n};\n\nmodule.exports = Queue;\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar Queue = require('../internals/queue');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar microtask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\nvar notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!microtask) {\n var queue = new Queue();\n\n var flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (fn = queue.get()) try {\n fn();\n } catch (error) {\n if (queue.head) notify();\n throw error;\n }\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessage\n // - onreadystatechange\n // - setTimeout\n } else {\n // `webpack` dev server bug on IE global methods - use bind(fn, global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n\n microtask = function (fn) {\n if (!queue.head) notify();\n queue.add(fn);\n };\n}\n\nmodule.exports = microtask;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","'use strict';\nvar global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n && typeof window == 'object'\n && typeof document == 'object';\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n // Detect correctness of subclassing with @@species support\n var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar $TypeError = TypeError;\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar IS_NODE = require('../internals/engine-is-node');\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar perform = require('../internals/perform');\nvar Queue = require('../internals/queue');\nvar InternalStateModule = require('../internals/internal-state');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar PromiseConstructorDetection = require('../internals/promise-constructor-detection');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\n\nvar PROMISE = 'Promise';\nvar FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;\nvar NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;\nvar NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar PromiseConstructor = NativePromiseConstructor;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar callReaction = function (reaction, state) {\n var value = state.value;\n var ok = state.state === FULFILLED;\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(new TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n microtask(function () {\n var reactions = state.reactions;\n var reaction;\n while (reaction = reactions.get()) {\n callReaction(reaction, state);\n }\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw new TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED_PROMISE_CONSTRUCTOR) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalPromiseState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n\n PromisePrototype = PromiseConstructor.prototype;\n\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: new Queue(),\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n state.parent = true;\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n if (state.state === PENDING) state.reactions.add(reaction);\n else microtask(function () {\n callReaction(reaction, state);\n });\n return reaction.promise;\n });\n\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalPromiseState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!NATIVE_PROMISE_SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n","'use strict';\nmodule.exports = function (a, b) {\n try {\n // eslint-disable-next-line no-console -- safe\n arguments.length === 1 ? console.error(a) : console.error(a, b);\n } catch (error) { /* empty */ }\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw new $TypeError(tryToString(argument) + ' is not iterable');\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_RECORD = !!(options && options.IS_RECORD);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_RECORD) {\n iterator = iterable.iterator;\n } else if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = IS_RECORD ? iterable.next : iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n try {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n } catch (error) { return false; } // workaround of old WebKit + `eval` bug\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.all` method\n// https://tc39.es/ecma262/#sec-promise.all\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar defineBuiltIn = require('../internals/define-built-in');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\n\n// `Promise.prototype.catch` method\n// https://tc39.es/ecma262/#sec-promise.prototype.catch\n$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n});\n\n// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromiseConstructor)) {\n var method = getBuiltIn('Promise').prototype['catch'];\n if (NativePromisePrototype['catch'] !== method) {\n defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.race` method\n// https://tc39.es/ecma262/#sec-promise.race\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\n// `Promise.reject` method\n// https://tc39.es/ecma262/#sec-promise.reject\n$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n reject: function reject(r) {\n var capability = newPromiseCapabilityModule.f(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar promiseResolve = require('../internals/promise-resolve');\n\nvar PromiseConstructorWrapper = getBuiltIn('Promise');\nvar CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;\n\n// `Promise.resolve` method\n// https://tc39.es/ecma262/#sec-promise.resolve\n$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {\n resolve: function resolve(x) {\n return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = function (METHOD_NAME, argument) {\n var method = [][METHOD_NAME];\n return !!method && fails(function () {\n // eslint-disable-next-line no-useless-call -- required for testing\n method.call(null, argument || function () { return 1; }, 1);\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar nativeJoin = uncurryThis([].join);\n\nvar ES3_STRINGS = IndexedObject !== Object;\nvar FORCED = ES3_STRINGS || !arrayMethodIsStrict('join', ',');\n\n// `Array.prototype.join` method\n// https://tc39.es/ecma262/#sec-array.prototype.join\n$({ target: 'Array', proto: true, forced: FORCED }, {\n join: function join(separator) {\n return nativeJoin(toIndexedObject(this), separator === undefined ? ',' : separator);\n }\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var props = toIndexedObject(Properties);\n var keys = objectKeys(Properties);\n var length = keys.length;\n var index = 0;\n var key;\n while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n return O;\n};\n","'use strict';\n/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n activeXDocument.write(scriptTag(''));\n activeXDocument.close();\n var temp = activeXDocument.parentWindow.Object;\n activeXDocument = null; // avoid memory leak\n return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = documentCreateElement('iframe');\n var JS = 'java' + SCRIPT + ':';\n var iframeDocument;\n iframe.style.display = 'none';\n html.appendChild(iframe);\n // https://github.com/zloirock/core-js/issues/475\n iframe.src = String(JS);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(scriptTag('document.F=Object'));\n iframeDocument.close();\n return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n try {\n activeXDocument = new ActiveXObject('htmlfile');\n } catch (error) { /* ignore */ }\n NullProtoObject = typeof document != 'undefined'\n ? document.domain && activeXDocument\n ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n : NullProtoObjectViaIFrame()\n : NullProtoObjectViaActiveX(activeXDocument); // WSH\n var length = enumBugKeys.length;\n while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n EmptyConstructor[PROTOTYPE] = anObject(O);\n result = new EmptyConstructor();\n EmptyConstructor[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = NullProtoObject();\n return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] === undefined) {\n defineProperty(ArrayPrototype, UNSCOPABLES, {\n configurable: true,\n value: create(null)\n });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n arrayIterator = [].keys();\n // Safari 8 has buggy iterators w/o `next`\n if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n else {\n PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {\n var test = {};\n // FF44- legacy iterators case\n return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n defineBuiltIn(IteratorPrototype, ITERATOR, function () {\n return this;\n });\n}\n\nmodule.exports = {\n IteratorPrototype: IteratorPrototype,\n BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n function F() { /* empty */ }\n F.prototype.constructor = null;\n // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar $Object = Object;\nvar ObjectPrototype = $Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n// eslint-disable-next-line es/no-object-getprototypeof -- safe\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {\n var object = toObject(O);\n if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n var constructor = object.constructor;\n if (isCallable(constructor) && object instanceof constructor) {\n return constructor.prototype;\n } return object instanceof $Object ? ObjectPrototype : null;\n};\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {\n var TO_STRING_TAG = NAME + ' Iterator';\n IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });\n setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n Iterators[TO_STRING_TAG] = returnThis;\n return IteratorConstructor;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/iterator-create-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n createIteratorConstructor(IteratorConstructor, NAME, next);\n\n var getIterationMethod = function (KIND) {\n if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];\n\n switch (KIND) {\n case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n }\n\n return function () { return new IteratorConstructor(this); };\n };\n\n var TO_STRING_TAG = NAME + ' Iterator';\n var INCORRECT_VALUES_NAME = false;\n var IterablePrototype = Iterable.prototype;\n var nativeIterator = IterablePrototype[ITERATOR]\n || IterablePrototype['@@iterator']\n || DEFAULT && IterablePrototype[DEFAULT];\n var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n var CurrentIteratorPrototype, methods, KEY;\n\n // fix native\n if (anyNativeIterator) {\n CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n if (setPrototypeOf) {\n setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);\n }\n }\n // Set @@toStringTag to native iterators\n setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n }\n }\n\n // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n } else {\n INCORRECT_VALUES_NAME = true;\n defaultIterator = function values() { return call(nativeIterator, this); };\n }\n }\n\n // export additional methods\n if (DEFAULT) {\n methods = {\n values: getIterationMethod(VALUES),\n keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n entries: getIterationMethod(ENTRIES)\n };\n if (FORCED) for (KEY in methods) {\n if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n defineBuiltIn(IterablePrototype, KEY, methods[KEY]);\n }\n } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n }\n\n // define iterator\n if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n }\n Iterators[NAME] = defaultIterator;\n\n return methods;\n};\n","'use strict';\n// `CreateIterResultObject` abstract operation\n// https://tc39.es/ecma262/#sec-createiterresultobject\nmodule.exports = function (value, done) {\n return { value: value, done: done };\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineProperty = require('../internals/object-define-property').f;\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar IS_PURE = require('../internals/is-pure');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n setInternalState(this, {\n type: ARRAY_ITERATOR,\n target: toIndexedObject(iterated), // target\n index: 0, // next index\n kind: kind // kind\n });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n var state = getInternalState(this);\n var target = state.target;\n var index = state.index++;\n if (!target || index >= target.length) {\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n switch (state.kind) {\n case 'keys': return createIterResultObject(index, false);\n case 'values': return createIterResultObject(target[index], false);\n } return createIterResultObject([index, target[index]], false);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nvar values = Iterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n// V8 ~ Chrome 45- bug\nif (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {\n defineProperty(values, 'name', { value: 'values' });\n} catch (error) { /* empty */ }\n","'use strict';\nvar classof = require('../internals/classof');\n\nvar $String = String;\n\nmodule.exports = function (argument) {\n if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n return $String(argument);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n return function ($this, pos) {\n var S = toString(requireObjectCoercible($this));\n var position = toIntegerOrInfinity(pos);\n var size = S.length;\n var first, second;\n if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n first = charCodeAt(S, position);\n return first < 0xD800 || first > 0xDBFF || position + 1 === size\n || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n ? CONVERT_TO_STRING\n ? charAt(S, position)\n : first\n : CONVERT_TO_STRING\n ? stringSlice(S, position, position + 2)\n : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n };\n};\n\nmodule.exports = {\n // `String.prototype.codePointAt` method\n // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n codeAt: createMethod(false),\n // `String.prototype.at` method\n // https://github.com/mathiasbynens/String.prototype.at\n charAt: createMethod(true)\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n setInternalState(this, {\n type: STRING_ITERATOR,\n string: toString(iterated),\n index: 0\n });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n var state = getInternalState(this);\n var string = state.string;\n var index = state.index;\n var point;\n if (index >= string.length) return createIterResultObject(undefined, true);\n point = charAt(string, index);\n state.index += point.length;\n return createIterResultObject(point, false);\n});\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n var propertyKey = toPropertyKey(key);\n if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n else object[propertyKey] = value;\n};\n","'use strict';\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\n\nvar $Array = Array;\nvar max = Math.max;\n\nmodule.exports = function (O, start, end) {\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n var result = $Array(max(fin - k, 0));\n var n = 0;\n for (; k < fin; k++, n++) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n};\n","'use strict';\n/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n try {\n return $getOwnPropertyNames(it);\n } catch (error) {\n return arraySlice(windowNames);\n }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n return windowNames && classof(it) === 'Window'\n ? getWindowNames(it)\n : $getOwnPropertyNames(toIndexedObject(it));\n};\n","'use strict';\n// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it\nvar fails = require('../internals/fails');\n\nmodule.exports = fails(function () {\n if (typeof ArrayBuffer == 'function') {\n var buffer = new ArrayBuffer(8);\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe\n if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar ARRAY_BUFFER_NON_EXTENSIBLE = require('../internals/array-buffer-non-extensible');\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar $isExtensible = Object.isExtensible;\nvar FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); });\n\n// `Object.isExtensible` method\n// https://tc39.es/ecma262/#sec-object.isextensible\nmodule.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) {\n if (!isObject(it)) return false;\n if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false;\n return $isExtensible ? $isExtensible(it) : true;\n} : $isExtensible;\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n return Object.isExtensible(Object.preventExtensions({}));\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar isExtensible = require('../internals/object-is-extensible');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar setMetadata = function (it) {\n defineProperty(it, METADATA, { value: {\n objectID: 'O' + id++, // object ID\n weakData: {} // weak collections IDs\n } });\n};\n\nvar fastKey = function (it, create) {\n // return a primitive with prefix\n if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return 'F';\n // not necessary to add metadata\n if (!create) return 'E';\n // add missing metadata\n setMetadata(it);\n // return object ID\n } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return true;\n // not necessary to add metadata\n if (!create) return false;\n // add missing metadata\n setMetadata(it);\n // return the store of weak collections IDs\n } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n return it;\n};\n\nvar enable = function () {\n meta.enable = function () { /* empty */ };\n REQUIRED = true;\n var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n var splice = uncurryThis([].splice);\n var test = {};\n test[METADATA] = 1;\n\n // prevent exposing of metadata key\n if (getOwnPropertyNames(test).length) {\n getOwnPropertyNamesModule.f = function (it) {\n var result = getOwnPropertyNames(it);\n for (var i = 0, length = result.length; i < length; i++) {\n if (result[i] === METADATA) {\n splice(result, i, 1);\n break;\n }\n } return result;\n };\n\n $({ target: 'Object', stat: true, forced: true }, {\n getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n });\n }\n};\n\nvar meta = module.exports = {\n enable: enable,\n fastKey: fastKey,\n getWeakData: getWeakData,\n onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n var NewTarget, NewTargetPrototype;\n if (\n // it can work only with native `setPrototypeOf`\n setPrototypeOf &&\n // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n isCallable(NewTarget = dummy.constructor) &&\n NewTarget !== Wrapper &&\n isObject(NewTargetPrototype = NewTarget.prototype) &&\n NewTargetPrototype !== Wrapper.prototype\n ) setPrototypeOf($this, NewTargetPrototype);\n return $this;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n var ADDER = IS_MAP ? 'set' : 'add';\n var NativeConstructor = global[CONSTRUCTOR_NAME];\n var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n var Constructor = NativeConstructor;\n var exported = {};\n\n var fixMethod = function (KEY) {\n var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n defineBuiltIn(NativePrototype, KEY,\n KEY === 'add' ? function add(value) {\n uncurriedNativeMethod(this, value === 0 ? 0 : value);\n return this;\n } : KEY === 'delete' ? function (key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'get' ? function get(key) {\n return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'has' ? function has(key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : function set(key, value) {\n uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n return this;\n }\n );\n };\n\n var REPLACE = isForced(\n CONSTRUCTOR_NAME,\n !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n new NativeConstructor().entries().next();\n }))\n );\n\n if (REPLACE) {\n // create collection constructor\n Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n InternalMetadataModule.enable();\n } else if (isForced(CONSTRUCTOR_NAME, true)) {\n var instance = new Constructor();\n // early implementations not supports chaining\n var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance;\n // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n // most early implementations doesn't supports iterables, most modern - not close it correctly\n // eslint-disable-next-line no-new -- required for testing\n var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n // for early implementations -0 and +0 not the same\n var BUGGY_ZERO = !IS_WEAK && fails(function () {\n // V8 ~ Chromium 42- fails only with 5+ elements\n var $instance = new NativeConstructor();\n var index = 5;\n while (index--) $instance[ADDER](index, index);\n return !$instance.has(-0);\n });\n\n if (!ACCEPT_ITERABLES) {\n Constructor = wrapper(function (dummy, iterable) {\n anInstance(dummy, NativePrototype);\n var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n return that;\n });\n Constructor.prototype = NativePrototype;\n NativePrototype.constructor = Constructor;\n }\n\n if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n fixMethod('delete');\n fixMethod('has');\n IS_MAP && fixMethod('get');\n }\n\n if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n // weak collections should not contains .clear method\n if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n }\n\n exported[CONSTRUCTOR_NAME] = Constructor;\n $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported);\n\n setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n return Constructor;\n};\n","'use strict';\nvar defineBuiltIn = require('../internals/define-built-in');\n\nmodule.exports = function (target, src, options) {\n for (var key in src) defineBuiltIn(target, key, src[key], options);\n return target;\n};\n","'use strict';\nvar classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n return classof(argument) === 'Array';\n};\n","'use strict';\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n var C;\n if (isArray(originalArray)) {\n C = originalArray.constructor;\n // cross-realm fallback\n if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;\n else if (isObject(C)) {\n C = C[SPECIES];\n if (C === null) C = undefined;\n }\n } return C === undefined ? $Array : C;\n};\n","'use strict';\nvar arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n var IS_MAP = TYPE === 1;\n var IS_FILTER = TYPE === 2;\n var IS_SOME = TYPE === 3;\n var IS_EVERY = TYPE === 4;\n var IS_FIND_INDEX = TYPE === 6;\n var IS_FILTER_REJECT = TYPE === 7;\n var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;\n return function ($this, callbackfn, that, specificCreate) {\n var O = toObject($this);\n var self = IndexedObject(O);\n var length = lengthOfArrayLike(self);\n var boundFunction = bind(callbackfn, that);\n var index = 0;\n var create = specificCreate || arraySpeciesCreate;\n var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n var value, result;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n value = self[index];\n result = boundFunction(value, index, O);\n if (TYPE) {\n if (IS_MAP) target[index] = result; // map\n else if (result) switch (TYPE) {\n case 3: return true; // some\n case 5: return value; // find\n case 6: return index; // findIndex\n case 2: push(target, value); // filter\n } else switch (TYPE) {\n case 4: return false; // every\n case 7: push(target, value); // filterReject\n }\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.forEach` method\n // https://tc39.es/ecma262/#sec-array.prototype.foreach\n forEach: createMethod(0),\n // `Array.prototype.map` method\n // https://tc39.es/ecma262/#sec-array.prototype.map\n map: createMethod(1),\n // `Array.prototype.filter` method\n // https://tc39.es/ecma262/#sec-array.prototype.filter\n filter: createMethod(2),\n // `Array.prototype.some` method\n // https://tc39.es/ecma262/#sec-array.prototype.some\n some: createMethod(3),\n // `Array.prototype.every` method\n // https://tc39.es/ecma262/#sec-array.prototype.every\n every: createMethod(4),\n // `Array.prototype.find` method\n // https://tc39.es/ecma262/#sec-array.prototype.find\n find: createMethod(5),\n // `Array.prototype.findIndex` method\n // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n findIndex: createMethod(6),\n // `Array.prototype.filterReject` method\n // https://github.com/tc39/proposal-array-filtering\n filterReject: createMethod(7)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar getWeakData = require('../internals/internal-metadata').getWeakData;\nvar anInstance = require('../internals/an-instance');\nvar anObject = require('../internals/an-object');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar iterate = require('../internals/iterate');\nvar ArrayIterationModule = require('../internals/array-iteration');\nvar hasOwn = require('../internals/has-own-property');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\nvar find = ArrayIterationModule.find;\nvar findIndex = ArrayIterationModule.findIndex;\nvar splice = uncurryThis([].splice);\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (state) {\n return state.frozen || (state.frozen = new UncaughtFrozenStore());\n};\n\nvar UncaughtFrozenStore = function () {\n this.entries = [];\n};\n\nvar findUncaughtFrozen = function (store, key) {\n return find(store.entries, function (it) {\n return it[0] === key;\n });\n};\n\nUncaughtFrozenStore.prototype = {\n get: function (key) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) return entry[1];\n },\n has: function (key) {\n return !!findUncaughtFrozen(this, key);\n },\n set: function (key, value) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) entry[1] = value;\n else this.entries.push([key, value]);\n },\n 'delete': function (key) {\n var index = findIndex(this.entries, function (it) {\n return it[0] === key;\n });\n if (~index) splice(this.entries, index, 1);\n return !!~index;\n }\n};\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n id: id++,\n frozen: undefined\n });\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var data = getWeakData(anObject(key), true);\n if (data === true) uncaughtFrozenStore(state).set(key, value);\n else data[state.id] = value;\n return that;\n };\n\n defineBuiltIns(Prototype, {\n // `{ WeakMap, WeakSet }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.delete\n // https://tc39.es/ecma262/#sec-weakset.prototype.delete\n 'delete': function (key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state)['delete'](key);\n return data && hasOwn(data, state.id) && delete data[state.id];\n },\n // `{ WeakMap, WeakSet }.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.has\n // https://tc39.es/ecma262/#sec-weakset.prototype.has\n has: function has(key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).has(key);\n return data && hasOwn(data, state.id);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `WeakMap.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.get\n get: function get(key) {\n var state = getInternalState(this);\n if (isObject(key)) {\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).get(key);\n return data ? data[state.id] : undefined;\n }\n },\n // `WeakMap.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.set\n set: function set(key, value) {\n return define(this, key, value);\n }\n } : {\n // `WeakSet.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-weakset.prototype.add\n add: function add(value) {\n return define(this, value, true);\n }\n });\n\n return Constructor;\n }\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionWeak = require('../internals/collection-weak');\n\n// `WeakSet` constructor\n// https://tc39.es/ecma262/#sec-weakset-constructor\ncollection('WeakSet', function (init) {\n return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionWeak);\n","'use strict';\n// iterable DOM collections\n// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods\nmodule.exports = {\n CSSRuleList: 0,\n CSSStyleDeclaration: 0,\n CSSValueList: 0,\n ClientRectList: 0,\n DOMRectList: 0,\n DOMStringList: 0,\n DOMTokenList: 1,\n DataTransferItemList: 0,\n FileList: 0,\n HTMLAllCollection: 0,\n HTMLCollection: 0,\n HTMLFormElement: 0,\n HTMLSelectElement: 0,\n MediaList: 0,\n MimeTypeArray: 0,\n NamedNodeMap: 0,\n NodeList: 1,\n PaintRequestList: 0,\n Plugin: 0,\n PluginArray: 0,\n SVGLengthList: 0,\n SVGNumberList: 0,\n SVGPathSegList: 0,\n SVGPointList: 0,\n SVGStringList: 0,\n SVGTransformList: 0,\n SourceBufferList: 0,\n StyleSheetList: 0,\n TextTrackCueList: 0,\n TextTrackList: 0,\n TouchList: 0\n};\n","'use strict';\n// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`\nvar documentCreateElement = require('../internals/document-create-element');\n\nvar classList = documentCreateElement('span').classList;\nvar DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;\n\nmodule.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nvar handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {\n if (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n } catch (error) {\n CollectionPrototype[ITERATOR] = ArrayValues;\n }\n setToStringTag(CollectionPrototype, COLLECTION_NAME, true);\n if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n } catch (error) {\n CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n }\n }\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);\n}\n\nhandlePrototype(DOMTokenListPrototype, 'DOMTokenList');\n","'use strict';\nvar $forEach = require('../internals/array-iteration').forEach;\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar STRICT_METHOD = arrayMethodIsStrict('forEach');\n\n// `Array.prototype.forEach` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.foreach\nmodule.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {\n return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n// eslint-disable-next-line es/no-array-prototype-foreach -- safe\n} : [].forEach;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar forEach = require('../internals/array-for-each');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar handlePrototype = function (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {\n createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);\n } catch (error) {\n CollectionPrototype.forEach = forEach;\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n if (DOMIterables[COLLECTION_NAME]) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype);\n }\n}\n\nhandlePrototype(DOMTokenListPrototype);\n","'use strict';\nvar $ = require('../internals/export');\nvar toObject = require('../internals/to-object');\nvar nativeKeys = require('../internals/object-keys');\nvar fails = require('../internals/fails');\n\nvar FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {\n keys: function keys(it) {\n return nativeKeys(toObject(it));\n }\n});\n","export enum ScrollDirection {\n SCROLL_NONE,\n SCROLL_BACKWARD,\n SCROLL_FORWARD,\n}\n\nexport enum Position {\n TOP,\n RIGHT,\n BOTTOM,\n LEFT,\n}\n\nexport const OPTIONS_DEFAULT_DOMAIN_TYPE = 'hour';\n\nexport const OPTIONS_DEFAULT_SUBDOMAIN_TYPE = 'minute';\nexport const OPTIONS_DEFAULT_SUBDOMAIN_WIDTH = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_GUTTER = 2;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_RADIUS = 0;\nexport const OPTIONS_DEFAULT_ANIMATION_DURATION = 200;\nexport const OPTIONS_DEFAULT_RANGE = 12;\nexport const OPTIONS_DEFAULT_ITEM_SELECTOR = '#cal-heatmap';\nexport const OPTIONS_DEFAULT_THEME = 'light';\nexport const OPTIONS_DEFAULT_LOCALE = 'en';\n\nexport const SCALE_BASE_OPACITY_COLOR = 'red';\nexport const SCALE_BASE_COLOR_SCHEME = 'YlOrBr';\nexport const SCALE_BASE_COLOR_TYPE = 'quantize';\nexport const SCALE_BASE_COLOR_DOMAIN = [0, 100];\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n var _, done = false;\r\n for (var i = decorators.length - 1; i >= 0; i--) {\r\n var context = {};\r\n for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n if (kind === \"accessor\") {\r\n if (result === void 0) continue;\r\n if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n if (_ = accept(result.get)) descriptor.get = _;\r\n if (_ = accept(result.set)) descriptor.set = _;\r\n if (_ = accept(result.init)) initializers.unshift(_);\r\n }\r\n else if (_ = accept(result)) {\r\n if (kind === \"field\") initializers.unshift(_);\r\n else descriptor[key] = _;\r\n }\r\n }\r\n if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n var useValue = arguments.length > 2;\r\n for (var i = 0; i < initializers.length; i++) {\r\n value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n }\r\n return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n 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;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n var desc = Object.getOwnPropertyDescriptor(m, k);\r\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n desc = { enumerable: true, get: function() { return m[k]; } };\r\n }\r\n Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport default {\r\n __extends,\r\n __assign,\r\n __rest,\r\n __decorate,\r\n __param,\r\n __metadata,\r\n __awaiter,\r\n __generator,\r\n __createBinding,\r\n __exportStar,\r\n __values,\r\n __read,\r\n __spread,\r\n __spreadArrays,\r\n __spreadArray,\r\n __await,\r\n __asyncGenerator,\r\n __asyncDelegator,\r\n __asyncValues,\r\n __makeTemplateObject,\r\n __importStar,\r\n __importDefault,\r\n __classPrivateFieldGet,\r\n __classPrivateFieldSet,\r\n __classPrivateFieldIn,\r\n};\r\n","import { Position } from '../constant';\nimport type { Padding } from '../options/Options';\n\nexport function isHorizontal(position: string): boolean {\n return position === 'left' || position === 'right';\n}\n\nexport function isVertical(position: string): boolean {\n return position === 'top' || position === 'bottom';\n}\n\nexport function horizontalPadding(padding: Padding): number {\n return padding[Position.LEFT] + padding[Position.RIGHT];\n}\n\nexport function verticalPadding(padding: Padding): number {\n return padding[Position.TOP] + padding[Position.BOTTOM];\n}\n","import { Position } from '../constant';\nimport {\n isHorizontal,\n isVertical,\n horizontalPadding,\n verticalPadding,\n} from '../helpers/PositionHelper';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { IPlugin, PluginOptions } from '../index';\nimport type { TextAlign, Padding } from '../options/Options';\n\ntype ComputedOptions = {\n radius: number;\n width: number;\n height: number;\n gutter: number;\n textAlign: TextAlign;\n};\n\ninterface CalendarLabelOptions extends PluginOptions, Partial {\n enabled: boolean;\n text: () => string[];\n padding: Padding;\n}\n\nconst DEFAULT_SELECTOR = '.ch-plugin-calendar-label';\n\nconst defaultOptions: CalendarLabelOptions = {\n enabled: true,\n\n dimensions: {\n width: 0,\n height: 0,\n },\n\n position: 'left',\n\n text: () => [],\n\n padding: [0, 0, 0, 0],\n};\n\nexport default class CalendarLabel implements IPlugin {\n name = 'CalendarLabel';\n\n calendar: CalHeatmap;\n\n root: any;\n\n shown: boolean;\n\n options: CalendarLabelOptions;\n\n computedOptions: ComputedOptions;\n\n constructor(calendar: CalHeatmap) {\n const subDomain = calendar?.options?.options?.subDomain;\n\n this.calendar = calendar;\n this.root = null;\n this.shown = false;\n this.options = defaultOptions;\n this.computedOptions = {\n radius: subDomain?.radius,\n width: subDomain?.width,\n height: subDomain?.height,\n gutter: subDomain?.gutter,\n textAlign: 'start',\n };\n }\n\n setup(pluginOptions?: Partial): void {\n this.options = { ...defaultOptions, ...pluginOptions };\n }\n\n paint(): Promise {\n const { enabled } = this.options;\n\n if (!enabled) {\n return this.destroy();\n }\n\n this.shown = true;\n\n const calendarRoot = this.calendar.calendarPainter.root;\n\n if (!this.root) {\n this.root = calendarRoot\n .append('svg')\n .attr('class', DEFAULT_SELECTOR.slice(1))\n .attr('data-key', this.options.key)\n .attr('x', 0)\n .attr('y', 0);\n }\n\n this.build();\n\n return Promise.resolve();\n }\n\n destroy(): Promise {\n if (this.root !== null) {\n this.root.remove();\n this.root = null;\n }\n\n return Promise.resolve();\n }\n\n build() {\n this.#buildComputedOptions();\n this.#computeDimensions();\n\n this.root\n .selectAll('g')\n .data(this.options.text)\n .join((enter: any) => enter\n .append('g')\n .call((selection: any) => selection\n .append('rect')\n .attr('class', `${DEFAULT_SELECTOR.slice(1)}-bg`)\n .attr('style', 'fill: transparent')\n .call((s: any) => this.#setRectAttr(s)))\n .call((selection: any) => selection\n .append('text')\n .attr('class', `${DEFAULT_SELECTOR.slice(1)}-text`)\n .attr('dominant-baseline', 'central')\n .attr('text-anchor', 'middle')\n .attr('style', 'fill: currentColor; font-size: 10px')\n .call((s: any) => this.#setTextAttr(s))));\n\n return Promise.resolve();\n }\n\n #buildComputedOptions() {\n Object.keys(this.computedOptions).forEach((key: string) => {\n if (typeof this.options[key as keyof ComputedOptions] !== 'undefined') {\n // @ts-ignore\n this.computedOptions[key] = this.options[key];\n }\n });\n }\n\n /**\n * Compute the total dimension of the current plugin\n */\n #computeDimensions(): void {\n const { width, height, gutter } = this.computedOptions;\n const { text, padding, position } = this.options;\n const labelsCount = text().length;\n\n this.options.dimensions = {\n width: width + horizontalPadding(padding),\n height: height + verticalPadding(padding),\n };\n\n if (isVertical(position!)) {\n this.options.dimensions.width += (width + gutter) * (labelsCount - 1);\n } else {\n this.options.dimensions.height += (height + gutter) * (labelsCount - 1);\n }\n }\n\n #setRectAttr(selection: any) {\n const { width, height, radius } = this.computedOptions;\n\n selection\n .attr('width', width)\n .attr('height', height)\n .attr('rx', radius && radius > 0 ? radius : null)\n .attr('ry', radius && radius > 0 ? radius : null)\n .attr('x', (_d: string, i: number) => this.#getX(i))\n .attr('y', (_d: string, i: number) => this.#getY(i));\n }\n\n #setTextAttr(selection: any): void {\n const { height, textAlign } = this.computedOptions;\n\n selection\n .attr('text-anchor', textAlign)\n .attr(\n 'x',\n (_d: string, i: number) => this.#getTextXOffset() + this.#getX(i),\n )\n .attr('y', (_d: string, i: number) => this.#getY(i) + height! / 2)\n .text((data: string) => data);\n }\n\n #getTextXOffset() {\n const { width, textAlign } = this.computedOptions;\n\n switch (textAlign) {\n case 'start':\n return 0;\n case 'middle':\n return width / 2;\n case 'end':\n return width;\n default:\n return 0;\n }\n }\n\n #getX(index: number) {\n const { position, padding } = this.options;\n const { width, gutter } = this.computedOptions;\n\n if (isHorizontal(position!)) {\n return padding[Position.LEFT];\n }\n\n return padding[Position.LEFT] + (width + gutter) * index;\n }\n\n #getY(index: number) {\n const { position, padding } = this.options;\n const { height, gutter } = this.computedOptions;\n\n if (isVertical(position!)) {\n return padding[Position.TOP];\n }\n\n return padding[Position.TOP] + (height + gutter) * index;\n }\n}\n"],"names":["fails","exec","error","descriptors","require$$0","Object","defineProperty","get","functionBindNative","test","bind","hasOwnProperty","NATIVE_BIND","FunctionPrototype","Function","prototype","call","uncurryThisWithBind","functionUncurryThis","fn","apply","arguments","isNullOrUndefined","it","$TypeError","TypeError","requireObjectCoercible","$Object","toObject","argument","require$$1","hasOwnProperty_1","hasOwn","key","DESCRIPTORS","getDescriptor","getOwnPropertyDescriptor","EXISTS","functionName","PROPER","name","CONFIGURABLE","configurable","makeBuiltIn$3","exports","documentAll","document","all","documentAll_1","IS_HTMLDDA","undefined","isCallable","check","Math","global","globalThis","window","self","this","defineGlobalProperty","value","writable","SHARED","sharedStore","store","require$$2","functionToString","toString","inspectSource","match","version","WeakMap","weakMapBasicDetection","String","isObject","objectDefineProperty","createElement","documentCreateElement","ie8DomDefine","a","v8PrototypeDefineBug","$String","anObject","functionCall","getBuiltIn","namespace","method","length","objectIsPrototypeOf","isPrototypeOf","engineUserAgent","navigator","userAgent","process","Deno","versions","v8","split","engineV8Version","V8_VERSION","symbolConstructorDetection","getOwnPropertySymbols","symbol","Symbol","sham","useSymbolAsUid","iterator","isSymbol","require$$3","$Symbol","tryToString","aCallable","getMethod","V","P","func","shared$3","sharedModule","push","mode","copyright","license","source","uncurryThis","id","postfix","random","uid","shared","NATIVE_SYMBOL","require$$4","USE_SYMBOL_AS_UID","require$$5","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","wellKnownSymbol","ordinaryToPrimitive","input","pref","val","valueOf","TO_PRIMITIVE","toPrimitive","result","exoticToPrim","toPropertyKey","IE8_DOM_DEFINE","V8_PROTOTYPE_DEFINE_BUG","$defineProperty","$getOwnPropertyDescriptor","ENUMERABLE","WRITABLE","f","O","Attributes","current","enumerable","set","has","createPropertyDescriptor","bitmap","definePropertyModule","createNonEnumerableProperty","object","keys","sharedKey","hiddenKeys","NATIVE_WEAK_MAP","require$$6","require$$7","OBJECT_ALREADY_INITIALIZED","state","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","CONFIGURABLE_FUNCTION_NAME","enforceInternalState","getInternalState","stringSlice","slice","replace","join","CONFIGURABLE_LENGTH","TEMPLATE","makeBuiltIn","makeBuiltInModule","options","getter","setter","arity","constructor","defineBuiltInAccessor","target","descriptor","FUNCTION_NAME_EXISTS","nameRE","regExpExec","objectGetOwnPropertyDescriptor","objectPropertyIsEnumerable","$propertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","classofRaw","classof","indexedObject","IndexedObject","toIndexedObject","propertyIsEnumerableModule","defineBuiltIn","simple","unsafe","nonConfigurable","nonWritable","ceil","floor","trunc","x","n","toIntegerOrInfinity","number","max","min","toAbsoluteIndex","index","integer","toLength","lengthOfArrayLike","obj","createMethod","IS_INCLUDES","$this","el","fromIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","i","enumBugKeys","internalObjectKeys","concat","objectGetOwnPropertyNames","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","ownKeys","getOwnPropertyDescriptorModule","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","toLowerCase","isForced_1","copyConstructorProperties","exceptions","_export","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","objectKeys","require$$8","$assign","assign","objectAssign","b","A","B","alphabet","forEach","chr","T","argumentsLength","S","j","toStringTagSupport","TO_STRING_TAG_SUPPORT","TO_STRING_TAG","CORRECT_ARGUMENTS","tag","tryGet","callee","engineIsNode","uncurryThisAccessor","aPossiblePrototype","objectSetPrototypeOf","setPrototypeOf","CORRECT_SETTER","Array","proto","__proto__","setToStringTag","TAG","SPECIES","anInstance","Prototype","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","$location","defer","channel","port","isConstructor","called","aConstructor","functionApply","Reflect","functionBindContext","that","html","arraySlice","engineIsIos","validateArgumentsLength","passed","required","IS_IOS","require$$10","IS_NODE","require$$11","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","location","run","runner","eventListener","event","globalPostMessageDefer","postMessage","protocol","host","handler","args","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","task","Queue","head","tail","add","item","entry","next","notify","toggle","node","promise","then","engineIsIosPebble","Pebble","engineIsWebosWebkit","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","Promise","queueMicrotaskDescriptor","microtask","flush","parent","domain","exit","enter","resolve","createTextNode","observe","characterData","microtask_1","perform","promiseNativeConstructor","engineIsDeno","engineIsBrowser","NativePromiseConstructor","IS_BROWSER","IS_DENO","require$$9","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","promiseConstructorDetection","CONSTRUCTOR","REJECTION_EVENT","newPromiseCapability$2","PromiseCapability","C","reject","$$resolve","$$reject","newPromiseCapability","Internal","OwnPromiseCapability","nativeThen","$","setSpecies","CONSTRUCTOR_NAME","Constructor","require$$12","speciesConstructor","defaultConstructor","require$$14","require$$15","hostReportErrors","console","require$$17","require$$18","InternalStateModule","require$$19","require$$20","newPromiseCapabilityModule","require$$22","PROMISE","require$$21","NATIVE_PROMISE_SUBCLASSING","getInternalPromiseState","setInternalState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","isThenable","callReaction","reaction","exited","ok","fail","rejection","onHandleUnhandled","isReject","notified","reactions","onUnhandled","reason","initEvent","isUnhandled","emit","unwrap","internalReject","done","internalResolve","wrapper","executor","onFulfilled","onRejected","PromiseWrapper","wrap","iterators","Iterators","ITERATOR","ArrayPrototype","getIteratorMethod","isArrayIteratorMethod","getIterator","usingIterator","iteratorMethod","iteratorClose","kind","innerResult","innerError","Result","stopped","ResultPrototype","iterate","iterable","unboundFunction","iterFn","step","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","SAFE_CLOSING","iteratorWithReturn","return","from","checkCorrectnessOfIteration","SKIP_CLOSING","ITERATION_SUPPORT","promiseStaticsIncorrectIteration","capability","$promiseResolve","values","remaining","alreadyCalled","real","catch","race","r","promiseResolve","promiseCapability","arrayMethodIsStrict","METHOD_NAME","nativeJoin","separator","objectDefineProperties","defineProperties","Properties","props","activeXDocument","definePropertiesModule","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","style","display","src","contentWindow","open","F","objectCreate","create","UNSCOPABLES","IteratorPrototype","PrototypeOfArrayIteratorPrototype","arrayIterator","correctPrototypeGetter","getPrototypeOf","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","objectGetPrototypeOf","BUGGY_SAFARI_ITERATORS","NEW_ITERATOR_PROTOTYPE","iteratorsCore","returnThis","createIteratorConstructor","IteratorConstructor","NAME","ENUMERABLE_NEXT","PROPER_FUNCTION_NAME","require$$13","KEYS","VALUES","ENTRIES","iteratorDefine","Iterable","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","createIterResultObject","addToUnscopables","defineIterator","ARRAY_ITERATOR","es_array_iterator","iterated","Arguments","charAt","charCodeAt","CONVERT_TO_STRING","pos","first","second","position","size","codeAt","STRING_ITERATOR","point","internalMetadata","objectGetOwnPropertyNamesExternal","createProperty","propertyKey","$Array","$getOwnPropertyNames","start","end","k","fin","windowNames","getWindowNames","arrayBufferNonExtensible","ArrayBuffer","buffer","isExtensible","ARRAY_BUFFER_NON_EXTENSIBLE","$isExtensible","objectIsExtensible","freezing","preventExtensions","getOwnPropertyNamesExternalModule","FREEZING","REQUIRED","METADATA","setMetadata","objectID","weakData","meta","internalMetadataModule","enable","splice","fastKey","getWeakData","onFreeze","InternalMetadataModule","inheritIfRequired","dummy","Wrapper","NewTarget","NewTargetPrototype","isArray","arraySpeciesConstructor","originalArray","arraySpeciesCreate","IS_MAP","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_REJECT","NO_HOLES","callbackfn","specificCreate","boundFunction","arrayIteration","map","filter","some","every","find","findIndex","filterReject","defineBuiltIns","internalStateGetterFor","uncaughtFrozenStore","frozen","UncaughtFrozenStore","findUncaughtFrozen","delete","collectionWeak","getConstructor","ADDER","define","common","IS_WEAK","NativeConstructor","NativePrototype","exported","fixMethod","uncurriedNativeMethod","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","setStrong","collection","init","domIterables","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DOMTokenList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","classList","DOMTokenListPrototype","domTokenListPrototype","DOMIterables","ArrayIteratorMethods","ArrayValues","handlePrototype","CollectionPrototype","COLLECTION_NAME","$forEach","ScrollDirection","Position","nativeKeys","__classPrivateFieldGet","receiver","isVertical","horizontalPadding","padding","LEFT","RIGHT","verticalPadding","TOP","BOTTOM","DEFAULT_SELECTOR","defaultOptions","enabled","dimensions","width","height","text","CalendarLabel","calendar","_classCallCheck","subDomain","_b","_a","root","shown","computedOptions","radius","gutter","textAlign","pluginOptions","destroy","calendarRoot","calendarPainter","append","attr","build","remove","_this","_CalendarLabel_instances","_CalendarLabel_buildComputedOptions","_CalendarLabel_computeDimensions","selectAll","selection","s","_CalendarLabel_setRectAttr","_CalendarLabel_setTextAttr","_this2","_this$computedOptions","_this$options","labelsCount","_this3","_this$computedOptions2","_d","_CalendarLabel_getX","_this4","_this$computedOptions3","_CalendarLabel_getY","_CalendarLabel_getTextXOffset","_this$computedOptions4","_this$options2","_this$computedOptions5","isHorizontal","_this$options3","_this$computedOptions6"],"mappings":"ooBACAA,EAAiB,SAAUC,GACzB,IACE,QAASA,GACV,CAAC,MAAOC,GACP,OAAO,CACR,CACH,ECHAC,GAHYC,GAGY,WAEtB,OAA+E,IAAxEC,OAAOC,eAAe,GAAI,EAAG,CAAEC,IAAK,WAAc,OAAO,CAAI,IAAI,EAC1E,ICJAC,GAFYJ,GAEY,WAEtB,IAAIK,EAAO,WAA4B,EAAEC,OAEzC,MAAsB,mBAARD,GAAsBA,EAAKE,eAAe,YAC1D,ICPIC,EAAcR,EAEdS,EAAoBC,SAASC,UAC7BC,EAAOH,EAAkBG,KACzBC,EAAsBL,GAAeC,EAAkBH,KAAKA,KAAKM,EAAMA,GAE3EE,EAAiBN,EAAcK,EAAsB,SAAUE,GAC7D,OAAO,WACL,OAAOH,EAAKI,MAAMD,EAAIE,UAC1B,CACA,ECRAC,EAAiB,SAAUC,GACzB,OAAOA,OACT,ECJID,EAAoBlB,EAEpBoB,EAAaC,UAIjBC,EAAiB,SAAUH,GACzB,GAAID,EAAkBC,GAAK,MAAM,IAAIC,EAAW,wBAA0BD,GAC1E,OAAOA,CACT,ECTIG,EAAyBtB,EAEzBuB,EAAUtB,OAIduB,EAAiB,SAAUC,GACzB,OAAOF,EAAQD,EAAuBG,GACxC,ECPID,EAAWE,EAEXnB,EAHcP,EAGe,GAAGO,gBAKpCoB,EAAiB1B,OAAO2B,QAAU,SAAgBT,EAAIU,GACpD,OAAOtB,EAAeiB,EAASL,GAAKU,EACtC,ECVIC,EAAc9B,EACd4B,EAASF,EAETjB,EAAoBC,SAASC,UAE7BoB,EAAgBD,GAAe7B,OAAO+B,yBAEtCC,EAASL,EAAOnB,EAAmB,QAKvCyB,EAAiB,CACfD,OAAQA,EACRE,OALWF,GAA0D,cAAhD,WAAqC,EAAEG,KAM5DC,aALiBJ,KAAYH,GAAgBA,GAAeC,EAActB,EAAmB,QAAQ6B,eCVvGC,EAAA,CAAAC,QAAA,CAAA,GAAIC,EAAiC,iBAAZC,UAAwBA,SAASC,IAM1DC,EAAiB,CACfD,IAAKF,EACLI,gBAJqC,IAAfJ,QAA8CK,IAAhBL,GCFlDA,EAFezC,EAEY2C,IAI/BI,EANmB/C,EAMW6C,WAAa,SAAUpB,GACnD,MAA0B,mBAAZA,GAA0BA,IAAagB,CACvD,EAAI,SAAUhB,GACZ,MAA0B,mBAAZA,CAChB,ECVIuB,EAAQ,SAAU7B,GACpB,OAAOA,GAAMA,EAAG8B,OAASA,MAAQ9B,CACnC,EAGA+B,EAEEF,EAA2B,iBAAdG,YAA0BA,aACvCH,EAAuB,iBAAVI,QAAsBA,SAEnCJ,EAAqB,iBAARK,MAAoBA,OACjCL,EAAuB,iBAAVE,GAAsBA,IACnCF,EAAqB,iBAARM,GAAoBA,IAEjC,WAAe,OAAOA,IAAO,CAA7B,IAAoC5C,SAAS,cAATA,GCdlCwC,EAASlD,EAGTE,EAAiBD,OAAOC,eAE5BqD,EAAiB,SAAU1B,EAAK2B,GAC9B,IACEtD,EAAegD,EAAQrB,EAAK,CAAE2B,MAAOA,EAAOlB,cAAc,EAAMmB,UAAU,GAC3E,CAAC,MAAO3D,GACPoD,EAAOrB,GAAO2B,CACf,CAAC,OAAOA,CACX,ECVID,EAAuB7B,EAEvBgC,EAAS,qBAGbC,EANa3D,EAIM0D,IAAWH,EAAqBG,EAAQ,CAAA,GCHvDX,EAAarB,EACbkC,EAAQC,EAERC,EAJc9D,EAIiBU,SAASqD,UAGvChB,EAAWa,EAAMI,iBACpBJ,EAAMI,cAAgB,SAAU7C,GAC9B,OAAO2C,EAAiB3C,EAC5B,OCHI8C,EAAOC,EDMXF,EAAiBJ,EAAMI,cEZnBjB,EAAarB,EAEbyC,EAHSnE,EAGQmE,QAErBC,EAAiBrB,EAAWoB,IAAY,cAAc9D,KAAKgE,OAAOF,ICL9DpB,EAAa/C,EAGbyC,EAFef,EAEYiB,IAE/B2B,EAJmB5C,EAIWmB,WAAa,SAAU1B,GACnD,MAAoB,iBAANA,EAAwB,OAAPA,EAAc4B,EAAW5B,IAAOA,IAAOsB,CACxE,EAAI,SAAUtB,GACZ,MAAoB,iBAANA,EAAwB,OAAPA,EAAc4B,EAAW5B,EAC1D,ECTAoD,EAAA,CAAA,EACID,EAAW5C,EAEXgB,EAHS1C,EAGS0C,SAElBT,GAASqC,EAAS5B,IAAa4B,EAAS5B,EAAS8B,eAErDC,GAAiB,SAAUtD,GACzB,OAAOc,GAASS,EAAS8B,cAAcrD,GAAM,CAAA,CAC/C,ECPIqD,GAAgBX,GAGpBa,IALkB1E,IACN0B,GAI4B,WAEtC,OAES,IAFFzB,OAAOC,eAAesE,GAAc,OAAQ,IAAK,CACtDrE,IAAK,WAAc,OAAO,CAAI,IAC7BwE,CACL,ICLAC,GALkB5E,GACN0B,GAI0B,WAEpC,OAGiB,KAHVzB,OAAOC,gBAAe,WAAY,GAAiB,YAAa,CACrEsD,MAAO,GACPC,UAAU,IACT9C,SACL,ICXI2D,GAAWtE,EAEX6E,GAAUR,OACVjD,GAAaC,UAGjByD,GAAiB,SAAUrD,GACzB,GAAI6C,GAAS7C,GAAW,OAAOA,EAC/B,MAAM,IAAIL,GAAWyD,GAAQpD,GAAY,oBAC3C,ECTIjB,GAAcR,EAEdY,GAAOF,SAASC,UAAUC,KAE9BmE,GAAiBvE,GAAcI,GAAKN,KAAKM,IAAQ,WAC/C,OAAOA,GAAKI,MAAMJ,GAAMK,UAC1B,ECNIiC,GAASlD,EACT+C,GAAarB,EAMjBsD,GAAiB,SAAUC,EAAWC,GACpC,OAAOjE,UAAUkE,OAAS,GALF1D,EAKgByB,GAAO+B,GAJxClC,GAAWtB,GAAYA,OAAWqB,GAIoBI,GAAO+B,IAAc/B,GAAO+B,GAAWC,GALtF,IAAUzD,CAM1B,ECPA2D,GAFkBpF,EAEW,CAAE,EAACqF,eCFhCC,GAAqC,oBAAbC,WAA4BlB,OAAOkB,UAAUC,YAAc,GVA/EtC,GAASlD,EACTwF,GAAY9D,GAEZ+D,GAAUvC,GAAOuC,QACjBC,GAAOxC,GAAOwC,KACdC,GAAWF,IAAWA,GAAQE,UAAYD,IAAQA,GAAKxB,QACvD0B,GAAKD,IAAYA,GAASC,GAG1BA,KAIF1B,GAHAD,EAAQ2B,GAAGC,MAAM,MAGD,GAAK,GAAK5B,EAAM,GAAK,EAAI,IAAMA,EAAM,GAAKA,EAAM,MAK7DC,GAAWsB,OACdvB,EAAQuB,GAAUvB,MAAM,iBACVA,EAAM,IAAM,MACxBA,EAAQuB,GAAUvB,MAAM,oBACbC,GAAWD,EAAM,IAIhC,IAAA6B,GAAiB5B,EWzBb6B,GAAa/F,GACbJ,GAAQ8B,EAGRmD,GAFShB,EAEQQ,OAGrB2B,KAAmB/F,OAAOgG,wBAA0BrG,IAAM,WACxD,IAAIsG,EAASC,OAAO,oBAKpB,OAAQtB,GAAQqB,MAAajG,OAAOiG,aAAmBC,UAEpDA,OAAOC,MAAQL,IAAcA,GAAa,EAC/C,ICdAM,GAFoBrG,KAGdmG,OAAOC,MACkB,iBAAnBD,OAAOG,SCLftB,GAAahF,GACb+C,GAAarB,EACb2D,GAAgBxB,GAGhBtC,GAAUtB,OAEdsG,GAJwBC,GAIa,SAAUrF,GAC7C,MAAoB,iBAANA,CAChB,EAAI,SAAUA,GACZ,IAAIsF,EAAUzB,GAAW,UACzB,OAAOjC,GAAW0D,IAAYpB,GAAcoB,EAAQ9F,UAAWY,GAAQJ,GACzE,ECZI0D,GAAUR,OAEdqC,GAAiB,SAAUjF,GACzB,IACE,OAAOoD,GAAQpD,EAChB,CAAC,MAAO3B,GACP,MAAO,QACR,CACH,ECRIiD,GAAa/C,EACb0G,GAAchF,GAEdN,GAAaC,UAGjBsF,GAAiB,SAAUlF,GACzB,GAAIsB,GAAWtB,GAAW,OAAOA,EACjC,MAAM,IAAIL,GAAWsF,GAAYjF,GAAY,qBAC/C,ECTIkF,GAAY3G,GACZkB,GAAoBQ,EAIxBkF,GAAiB,SAAUC,EAAGC,GAC5B,IAAIC,EAAOF,EAAEC,GACb,OAAO5F,GAAkB6F,QAAQjE,EAAY6D,GAAUI,EACzD,ECRInG,GAAOZ,GACP+C,GAAarB,EACb4C,GAAWT,EAEXzC,GAAaC,UCHjB2F,GAAA,CAAAxE,QAAA,CAAA,GAAIoB,GAAQlC,GAEXuF,WAAiB,SAAUpF,EAAK2B,GAC/B,OAAOI,GAAM/B,KAAS+B,GAAM/B,QAAiBiB,IAAVU,EAAsBA,EAAQ,CAAA,EACnE,GAAG,WAAY,IAAI0D,KAAK,CACtBhD,QAAS,SACTiD,KAAyB,SACzBC,UAAW,4CACXC,QAAS,2DACTC,OAAQ,0DCVNC,GAAcvH,EAEdwH,GAAK,EACLC,GAAUxE,KAAKyE,SACf3D,GAAWwD,GAAY,GAAIxD,UAE/B4D,GAAiB,SAAU9F,GACzB,MAAO,gBAAqBiB,IAARjB,EAAoB,GAAKA,GAAO,KAAOkC,KAAWyD,GAAKC,GAAS,GACtF,ECPIG,GAASlG,GACTE,GAASiC,EACT8D,GAAMnB,GACNqB,GAAgBC,GAChBC,GAAoBC,GAEpB7B,GAPSnG,EAOOmG,OAChB8B,GAAwBL,GAAO,OAC/BM,GAAwBH,GAAoB5B,GAAY,KAAKA,GAASA,IAAUA,GAAOgC,eAAiBR,GAE5GS,GAAiB,SAAUhG,GAKvB,OAJGR,GAAOqG,GAAuB7F,KACjC6F,GAAsB7F,GAAQyF,IAAiBjG,GAAOuE,GAAQ/D,GAC1D+D,GAAO/D,GACP8F,GAAsB,UAAY9F,IAC/B6F,GAAsB7F,EACjC,ECjBIxB,GAAOZ,GACPsE,GAAW5C,EACX6E,GAAW1C,GACX+C,GAAYJ,GACZ6B,GJIa,SAAUC,EAAOC,GAChC,IAAIxH,EAAIyH,EACR,GAAa,WAATD,GAAqBxF,GAAWhC,EAAKuH,EAAMvE,YAAcO,GAASkE,EAAM5H,GAAKG,EAAIuH,IAAS,OAAOE,EACrG,GAAIzF,GAAWhC,EAAKuH,EAAMG,WAAanE,GAASkE,EAAM5H,GAAKG,EAAIuH,IAAS,OAAOE,EAC/E,GAAa,WAATD,GAAqBxF,GAAWhC,EAAKuH,EAAMvE,YAAcO,GAASkE,EAAM5H,GAAKG,EAAIuH,IAAS,OAAOE,EACrG,MAAM,IAAIpH,GAAW,0CACvB,EIPIA,GAAaC,UACbqH,GAHkBV,GAGa,eCR/BW,GDYa,SAAUL,EAAOC,GAChC,IAAKjE,GAASgE,IAAU/B,GAAS+B,GAAQ,OAAOA,EAChD,IACIM,EADAC,EAAejC,GAAU0B,EAAOI,IAEpC,GAAIG,EAAc,CAGhB,QAFa/F,IAATyF,IAAoBA,EAAO,WAC/BK,EAAShI,GAAKiI,EAAcP,EAAOC,IAC9BjE,GAASsE,IAAWrC,GAASqC,GAAS,OAAOA,EAClD,MAAM,IAAIxH,GAAW,0CACtB,CAED,YADa0B,IAATyF,IAAoBA,EAAO,UACxBF,GAAoBC,EAAOC,EACpC,ECvBIhC,GAAW7E,GAIfoH,GAAiB,SAAUrH,GACzB,IAAII,EAAM8G,GAAYlH,EAAU,UAChC,OAAO8E,GAAS1E,GAAOA,EAAMA,EAAM,EACrC,ECRIC,GAAc9B,EACd+I,GAAiBrH,GACjBsH,GAA0BnF,GAC1BiB,GAAW0B,GACXsC,GAAgBhB,GAEhB1G,GAAaC,UAEb4H,GAAkBhJ,OAAOC,eAEzBgJ,GAA4BjJ,OAAO+B,yBACnCmH,GAAa,aACb9G,GAAe,eACf+G,GAAW,WAIf7E,EAAA8E,EAAYvH,GAAckH,GAA0B,SAAwBM,EAAGxC,EAAGyC,GAIhF,GAHAzE,GAASwE,GACTxC,EAAIgC,GAAchC,GAClBhC,GAASyE,GACQ,mBAAND,GAA0B,cAANxC,GAAqB,UAAWyC,GAAcH,MAAYG,IAAeA,EAAWH,IAAW,CAC5H,IAAII,EAAUN,GAA0BI,EAAGxC,GACvC0C,GAAWA,EAAQJ,MACrBE,EAAExC,GAAKyC,EAAW/F,MAClB+F,EAAa,CACXjH,aAAcD,MAAgBkH,EAAaA,EAAWlH,IAAgBmH,EAAQnH,IAC9EoH,WAAYN,MAAcI,EAAaA,EAAWJ,IAAcK,EAAQL,IACxE1F,UAAU,GAGf,CAAC,OAAOwF,GAAgBK,EAAGxC,EAAGyC,EACjC,EAAIN,GAAkB,SAAwBK,EAAGxC,EAAGyC,GAIlD,GAHAzE,GAASwE,GACTxC,EAAIgC,GAAchC,GAClBhC,GAASyE,GACLR,GAAgB,IAClB,OAAOE,GAAgBK,EAAGxC,EAAGyC,EACjC,CAAI,MAAOzJ,GAAsB,CAC/B,GAAI,QAASyJ,GAAc,QAASA,EAAY,MAAM,IAAInI,GAAW,2BAErE,MADI,UAAWmI,IAAYD,EAAExC,GAAKyC,EAAW/F,OACtC8F,CACT,EC1CA,ICYII,GAAKvJ,GAAKwJ,GDZdC,GAAiB,SAAUC,EAAQrG,GACjC,MAAO,CACLiG,aAAuB,EAATI,GACdvH,eAAyB,EAATuH,GAChBpG,WAAqB,EAAToG,GACZrG,MAAOA,EAEX,EENIsG,GAAuBpI,EACvBkI,GAA2B/F,GAE/BkG,GAJkB/J,EAIa,SAAUgK,EAAQnI,EAAK2B,GACpD,OAAOsG,GAAqBT,EAAEW,EAAQnI,EAAK+H,GAAyB,EAAGpG,GACzE,EAAI,SAAUwG,EAAQnI,EAAK2B,GAEzB,OADAwG,EAAOnI,GAAO2B,EACPwG,CACT,ECRIrC,GAAMjG,GAENuI,GAHSjK,GAGK,QAElBkK,GAAiB,SAAUrI,GACzB,OAAOoI,GAAKpI,KAASoI,GAAKpI,GAAO8F,GAAI9F,GACvC,ECPAsI,GAAiB,CAAA,EHAbC,GAAkBpK,EAClBkD,GAASxB,EACT4C,GAAWT,EACXkG,GAA8BvD,GAC9B5E,GAASkG,EACTF,GAASI,EACTkC,GAAYG,GACZF,GAAaG,GAEbC,GAA6B,6BAC7BlJ,GAAY6B,GAAO7B,UACnB8C,GAAUjB,GAAOiB,QAgBrB,GAAIiG,IAAmBxC,GAAO4C,MAAO,CACnC,IAAI5G,GAAQgE,GAAO4C,QAAU5C,GAAO4C,MAAQ,IAAIrG,IAEhDP,GAAMzD,IAAMyD,GAAMzD,IAClByD,GAAM+F,IAAM/F,GAAM+F,IAClB/F,GAAM8F,IAAM9F,GAAM8F,IAElBA,GAAM,SAAUvI,EAAIsJ,GAClB,GAAI7G,GAAM+F,IAAIxI,GAAK,MAAM,IAAIE,GAAUkJ,IAGvC,OAFAE,EAASC,OAASvJ,EAClByC,GAAM8F,IAAIvI,EAAIsJ,GACPA,CACX,EACEtK,GAAM,SAAUgB,GACd,OAAOyC,GAAMzD,IAAIgB,IAAO,CAAA,CAC5B,EACEwI,GAAM,SAAUxI,GACd,OAAOyC,GAAM+F,IAAIxI,EACrB,CACA,KAAO,CACL,IAAIwJ,GAAQT,GAAU,SACtBC,GAAWQ,KAAS,EACpBjB,GAAM,SAAUvI,EAAIsJ,GAClB,GAAI7I,GAAOT,EAAIwJ,IAAQ,MAAM,IAAItJ,GAAUkJ,IAG3C,OAFAE,EAASC,OAASvJ,EAClB4I,GAA4B5I,EAAIwJ,GAAOF,GAChCA,CACX,EACEtK,GAAM,SAAUgB,GACd,OAAOS,GAAOT,EAAIwJ,IAASxJ,EAAGwJ,IAAS,EAC3C,EACEhB,GAAM,SAAUxI,GACd,OAAOS,GAAOT,EAAIwJ,GACtB,CACA,CAEA,IAAAC,GAAiB,CACflB,IAAKA,GACLvJ,IAAKA,GACLwJ,IAAKA,GACLkB,QArDY,SAAU1J,GACtB,OAAOwI,GAAIxI,GAAMhB,GAAIgB,GAAMuI,GAAIvI,EAAI,CAAA,EACrC,EAoDE2J,UAlDc,SAAUC,GACxB,OAAO,SAAU5J,GACf,IAAIqJ,EACJ,IAAKlG,GAASnD,KAAQqJ,EAAQrK,GAAIgB,IAAK6J,OAASD,EAC9C,MAAM,IAAI1J,GAAU,0BAA4B0J,EAAO,aACvD,OAAOP,CACb,CACA,GIzBIjD,GAAcvH,EACdJ,GAAQ8B,EACRqB,GAAac,EACbjC,GAAS4E,EACT1E,GAAcgG,EACdmD,GAA6BjD,EAAsC3F,aACnE2B,GAAgBqG,EAGhBa,GAFsBZ,GAEqBO,QAC3CM,GAHsBb,GAGiBnK,IACvC0E,GAAUR,OAEVnE,GAAiBD,OAAOC,eACxBkL,GAAc7D,GAAY,GAAG8D,OAC7BC,GAAU/D,GAAY,GAAG+D,SACzBC,GAAOhE,GAAY,GAAGgE,MAEtBC,GAAsB1J,KAAgBlC,IAAM,WAC9C,OAAsF,IAA/EM,IAAe,WAA2B,GAAE,SAAU,CAAEsD,MAAO,IAAK2B,MAC7E,IAEIsG,GAAWpH,OAAOA,QAAQwB,MAAM,UAEhC6F,GAAcC,EAAAnJ,QAAiB,SAAUgB,EAAOpB,EAAMwJ,GACf,YAArCR,GAAYvG,GAAQzC,GAAO,EAAG,KAChCA,EAAO,IAAMkJ,GAAQzG,GAAQzC,GAAO,qBAAsB,MAAQ,KAEhEwJ,GAAWA,EAAQC,SAAQzJ,EAAO,OAASA,GAC3CwJ,GAAWA,EAAQE,SAAQ1J,EAAO,OAASA,KAC1CR,GAAO4B,EAAO,SAAYyH,IAA8BzH,EAAMpB,OAASA,KACtEN,GAAa5B,GAAesD,EAAO,OAAQ,CAAEA,MAAOpB,EAAME,cAAc,IACvEkB,EAAMpB,KAAOA,GAEhBoJ,IAAuBI,GAAWhK,GAAOgK,EAAS,UAAYpI,EAAM2B,SAAWyG,EAAQG,OACzF7L,GAAesD,EAAO,SAAU,CAAEA,MAAOoI,EAAQG,QAEnD,IACMH,GAAWhK,GAAOgK,EAAS,gBAAkBA,EAAQI,YACnDlK,IAAa5B,GAAesD,EAAO,YAAa,CAAEC,UAAU,IAEvDD,EAAM7C,YAAW6C,EAAM7C,eAAYmC,EAClD,CAAI,MAAOhD,GAAsB,CAC/B,IAAI0K,EAAQU,GAAqB1H,GAG/B,OAFG5B,GAAO4I,EAAO,YACjBA,EAAMlD,OAASiE,GAAKE,GAAyB,iBAARrJ,EAAmBA,EAAO,KACxDoB,CACX,EAIA9C,SAASC,UAAUoD,SAAW2H,IAAY,WACxC,OAAO3I,GAAWO,OAAS6H,GAAiB7H,MAAMgE,QAAUtD,GAAcV,KAC5E,GAAG,6BCrDCoI,GAAc1L,GACdE,GAAiBwB,EAErBuK,GAAiB,SAAUC,EAAQ9J,EAAM+J,GAGvC,OAFIA,EAAWhM,KAAKuL,GAAYS,EAAWhM,IAAKiC,EAAM,CAAEyJ,QAAQ,IAC5DM,EAAWzC,KAAKgC,GAAYS,EAAWzC,IAAKtH,EAAM,CAAE0J,QAAQ,IACzD5L,GAAemJ,EAAE6C,EAAQ9J,EAAM+J,EACxC,ECPIrK,GAAc9B,EACdoM,GAAuB1K,EAAsCO,OAC7DsF,GAAc1D,EACdoI,GAAwBzF,GAExB/F,GAAoBC,SAASC,UAC7BmD,GAAmByD,GAAY9G,GAAkBsD,UACjDsI,GAAS,mEACTC,GAAa/E,GAAY8E,GAAOxM,MAKhCiC,KAAgBsK,IAClBH,GAAsBxL,GALb,OAKsC,CAC7C6B,cAAc,EACdnC,IAAK,WACH,IACE,OAAOmM,GAAWD,GAAQvI,GAAiBR,OAAO,EACnD,CAAC,MAAOxD,GACP,MAAO,EACR,CACF,IAEL,IAAAyM,GAAA,CAAA,EAAAC,GAAA,CAAA,ECxBIC,GAAwB,CAAE,EAACC,qBAE3B1K,GAA2B/B,OAAO+B,yBAGlC2K,GAAc3K,KAA6ByK,GAAsB7L,KAAK,CAAE,EAAG,GAAK,GAIpF4L,GAAAnD,EAAYsD,GAAc,SAA8B9F,GACtD,IAAIsF,EAAanK,GAAyBsB,KAAMuD,GAChD,QAASsF,GAAcA,EAAW1C,UACpC,EAAIgD,GCZJ,IAAIlF,GAAcvH,EAEd+D,GAAWwD,GAAY,GAAGxD,UAC1BqH,GAAc7D,GAAY,GAAG8D,OAEjCuB,GAAiB,SAAUzL,GACzB,OAAOiK,GAAYrH,GAAS5C,GAAK,GAAI,EACvC,ECNIvB,GAAQ8B,EACRmL,GAAUhJ,GAEVtC,GAAUtB,OACV4F,GALc7F,EAKM,GAAG6F,OAG3BiH,GAAiBlN,IAAM,WAGrB,OAAQ2B,GAAQ,KAAKmL,qBAAqB,EAC5C,IAAK,SAAUvL,GACb,MAAuB,WAAhB0L,GAAQ1L,GAAmB0E,GAAM1E,EAAI,IAAMI,GAAQJ,EAC5D,EAAII,GCbAwL,GAAgB/M,GAChBsB,GAAyBI,EAE7BsL,GAAiB,SAAU7L,GACzB,OAAO4L,GAAczL,GAAuBH,GAC9C,ECNIW,GAAc9B,EACdY,GAAOc,GACPuL,GAA6BpJ,GAC7B+F,GAA2BpD,GAC3BwG,GAAkBlF,GAClBgB,GAAgBd,GAChBpG,GAASyI,EACTtB,GAAiBuB,GAGjBpB,GAA4BjJ,OAAO+B,yBAI9BuK,GAAAlD,EAAGvH,GAAcoH,GAA4B,SAAkCI,EAAGxC,GAGzF,GAFAwC,EAAI0D,GAAgB1D,GACpBxC,EAAIgC,GAAchC,GACdiC,GAAgB,IAClB,OAAOG,GAA0BI,EAAGxC,EACxC,CAAI,MAAOhH,GAAsB,CAC/B,GAAI8B,GAAO0H,EAAGxC,GAAI,OAAO8C,IAA0BhJ,GAAKqM,GAA2B5D,EAAGC,EAAGxC,GAAIwC,EAAExC,GACjG,ECrBA,IAAI/D,GAAa/C,EACb8J,GAAuBpI,EACvBgK,GAAc7H,GACdN,GAAuBiD,EAE3B0G,GAAiB,SAAU5D,EAAGzH,EAAK2B,EAAOoI,GACnCA,IAASA,EAAU,IACxB,IAAIuB,EAASvB,EAAQnC,WACjBrH,OAAwBU,IAAjB8I,EAAQxJ,KAAqBwJ,EAAQxJ,KAAOP,EAEvD,GADIkB,GAAWS,IAAQkI,GAAYlI,EAAOpB,EAAMwJ,GAC5CA,EAAQ1I,OACNiK,EAAQ7D,EAAEzH,GAAO2B,EAChBD,GAAqB1B,EAAK2B,OAC1B,CACL,IACOoI,EAAQwB,OACJ9D,EAAEzH,KAAMsL,GAAS,UADE7D,EAAEzH,EAEpC,CAAM,MAAO/B,GAAsB,CAC3BqN,EAAQ7D,EAAEzH,GAAO2B,EAChBsG,GAAqBT,EAAEC,EAAGzH,EAAK,CAClC2B,MAAOA,EACPiG,YAAY,EACZnH,cAAesJ,EAAQyB,gBACvB5J,UAAWmI,EAAQ0B,aAEtB,CAAC,OAAOhE,CACX,QC1BIiE,GAAOtK,KAAKsK,KACZC,GAAQvK,KAAKuK,MCDbC,GDMaxK,KAAKwK,OAAS,SAAeC,GAC5C,IAAIC,GAAKD,EACT,OAAQC,EAAI,EAAIH,GAAQD,IAAMI,EAChC,ECLAC,GAAiB,SAAUnM,GACzB,IAAIoM,GAAUpM,EAEd,OAAOoM,GAAWA,GAAqB,IAAXA,EAAe,EAAIJ,GAAMI,EACvD,ECRID,GAAsB5N,GAEtB8N,GAAM7K,KAAK6K,IACXC,GAAM9K,KAAK8K,IAKfC,GAAiB,SAAUC,EAAO9I,GAChC,IAAI+I,EAAUN,GAAoBK,GAClC,OAAOC,EAAU,EAAIJ,GAAII,EAAU/I,EAAQ,GAAK4I,GAAIG,EAAS/I,EAC/D,ECXIyI,GAAsB5N,GAEtB+N,GAAM9K,KAAK8K,ICFXI,GDMa,SAAU1M,GACzB,OAAOA,EAAW,EAAIsM,GAAIH,GAAoBnM,GAAW,kBAAoB,CAC/E,ECJA2M,GAAiB,SAAUC,GACzB,OAAOF,GAASE,EAAIlJ,OACtB,ECNI6H,GAAkBhN,GAClBgO,GAAkBtM,GAClB0M,GAAoBvK,GAGpByK,GAAe,SAAUC,GAC3B,OAAO,SAAUC,EAAOC,EAAIC,GAC1B,IAGIlL,EAHA8F,EAAI0D,GAAgBwB,GACpBrJ,EAASiJ,GAAkB9E,GAC3B2E,EAAQD,GAAgBU,EAAWvJ,GAIvC,GAAIoJ,GAAeE,GAAOA,GAAI,KAAOtJ,EAAS8I,GAG5C,IAFAzK,EAAQ8F,EAAE2E,OAEIzK,EAAO,OAAO,OAEvB,KAAM2B,EAAS8I,EAAOA,IAC3B,IAAKM,GAAeN,KAAS3E,IAAMA,EAAE2E,KAAWQ,EAAI,OAAOF,GAAeN,GAAS,EACnF,OAAQM,IAAgB,CAC9B,CACA,EAEAI,GAAiB,CAGfC,SAAUN,IAAa,GAGvBO,QAASP,IAAa,IC7BpB1M,GAASF,EACTsL,GAAkBnJ,GAClBgL,GAAUrI,GAAuCqI,QACjD1E,GAAarC,GAEbZ,GANclH,EAMK,GAAGkH,MAE1B4H,GAAiB,SAAU9E,EAAQ+E,GACjC,IAGIlN,EAHAyH,EAAI0D,GAAgBhD,GACpBgF,EAAI,EACJpG,EAAS,GAEb,IAAK/G,KAAOyH,GAAI1H,GAAOuI,GAAYtI,IAAQD,GAAO0H,EAAGzH,IAAQqF,GAAK0B,EAAQ/G,GAE1E,KAAOkN,EAAM5J,OAAS6J,GAAOpN,GAAO0H,EAAGzH,EAAMkN,EAAMC,SAChDH,GAAQjG,EAAQ/G,IAAQqF,GAAK0B,EAAQ/G,IAExC,OAAO+G,CACT,EClBAqG,GAAiB,CACf,cACA,iBACA,gBACA,uBACA,iBACA,WACA,WCREC,GAAqBlP,GAGrBmK,GAFczI,GAEWyN,OAAO,SAAU,aAKrCC,GAAA/F,EAAGpJ,OAAOoP,qBAAuB,SAA6B/F,GACrE,OAAO4F,GAAmB5F,EAAGa,GAC/B,ECVA,IAAAmF,GAAA,CAAA,EACSA,GAAAjG,EAAGpJ,OAAOgG,sBCDnB,IAAIjB,GAAahF,GAEbuP,GAA4B1L,GAC5B2L,GAA8BhJ,GAC9B1B,GAAWgD,GAEXqH,GALczN,EAKO,GAAGyN,QAG5BM,GAAiBzK,GAAW,UAAW,YAAc,SAAiB7D,GACpE,IAAI8I,EAAOsF,GAA0BlG,EAAEvE,GAAS3D,IAC5C8E,EAAwBuJ,GAA4BnG,EACxD,OAAOpD,EAAwBkJ,GAAOlF,EAAMhE,EAAsB9E,IAAO8I,CAC3E,ECbIrI,GAAS5B,EACTyP,GAAU/N,GACVgO,GAAiC7L,GACjCiG,GAAuBtD,ECHvB5G,GAAQI,EACR+C,GAAarB,EAEbiO,GAAc,kBAEdC,GAAW,SAAUC,EAASC,GAChC,IAAItM,EAAQuM,GAAKC,GAAUH,IAC3B,OAAOrM,IAAUyM,IACbzM,IAAU0M,KACVnN,GAAW+M,GAAalQ,GAAMkQ,KAC5BA,EACR,EAEIE,GAAYJ,GAASI,UAAY,SAAUG,GAC7C,OAAO9L,OAAO8L,GAAQ7E,QAAQqE,GAAa,KAAKS,aAClD,EAEIL,GAAOH,GAASG,KAAO,GACvBG,GAASN,GAASM,OAAS,IAC3BD,GAAWL,GAASK,SAAW,IAEnCI,GAAiBT,GCrBb1M,GAASlD,EACTgC,GAA2BN,GAA2D2H,EACtFU,GAA8BlG,GAC9BqJ,GAAgB1G,GAChBjD,GAAuBuE,EACvBwI,GFAa,SAAUpE,EAAQ5E,EAAQiJ,GAIzC,IAHA,IAAItG,EAAOwF,GAAQnI,GACfpH,EAAiB4J,GAAqBT,EACtCrH,EAA2B0N,GAA+BrG,EACrD2F,EAAI,EAAGA,EAAI/E,EAAK9E,OAAQ6J,IAAK,CACpC,IAAInN,EAAMoI,EAAK+E,GACVpN,GAAOsK,EAAQrK,IAAU0O,GAAc3O,GAAO2O,EAAY1O,IAC7D3B,EAAegM,EAAQrK,EAAKG,EAAyBsF,EAAQzF,GAEhE,CACH,EETI+N,GAAWvF,GAiBfmG,GAAiB,SAAU5E,EAAStE,GAClC,IAGY4E,EAAQrK,EAAK4O,EAAgBC,EAAgBvE,EAHrDwE,EAAS/E,EAAQM,OACjB0E,EAAShF,EAAQ1I,OACjB2N,EAASjF,EAAQkF,KASrB,GANE5E,EADE0E,EACO1N,GACA2N,EACA3N,GAAOyN,IAAWpN,GAAqBoN,EAAQ,CAAA,IAE9CzN,GAAOyN,IAAW,CAAA,GAAIhQ,UAEtB,IAAKkB,KAAOyF,EAAQ,CAQ9B,GAPAoJ,EAAiBpJ,EAAOzF,GAGtB4O,EAFE7E,EAAQmF,gBACV5E,EAAanK,GAAyBkK,EAAQrK,KACfsK,EAAW3I,MACpB0I,EAAOrK,IACtB+N,GAASgB,EAAS/O,EAAM8O,GAAUE,EAAS,IAAM,KAAOhP,EAAK+J,EAAQoF,cAE5ClO,IAAnB2N,EAA8B,CAC3C,UAAWC,UAAyBD,EAAgB,SACpDH,GAA0BI,EAAgBD,EAC3C,EAEG7E,EAAQxF,MAASqK,GAAkBA,EAAerK,OACpD2D,GAA4B2G,EAAgB,QAAQ,GAEtDxD,GAAchB,EAAQrK,EAAK6O,EAAgB9E,EAC5C,CACH,ECrDIsD,GAAqBlP,GACrBiP,GAAcvN,GAKlBuP,GAAiBhR,OAAOgK,MAAQ,SAAcX,GAC5C,OAAO4F,GAAmB5F,EAAG2F,GAC/B,ECRInN,GAAc9B,EACduH,GAAc7F,EACdd,GAAOiD,GACPjE,GAAQ4G,EACRyK,GAAanJ,GACb0H,GAA8BxH,GAC9BiF,GAA6B5C,GAC7B7I,GAAW8I,EACXyC,GAAgBmE,GAGhBC,GAAUlR,OAAOmR,OAEjBlR,GAAiBD,OAAOC,eACxBiP,GAAS5H,GAAY,GAAG4H,QAI5BkC,IAAkBF,IAAWvR,IAAM,WAEjC,GAAIkC,IAQiB,IARFqP,GAAQ,CAAEG,EAAG,GAAKH,GAAQjR,GAAe,CAAE,EAAE,IAAK,CACnEuJ,YAAY,EACZtJ,IAAK,WACHD,GAAeoD,KAAM,IAAK,CACxBE,MAAO,EACPiG,YAAY,GAEf,IACC,CAAE6H,EAAG,KAAMA,EAAS,OAAO,EAE/B,IAAIC,EAAI,CAAA,EACJC,EAAI,CAAA,EAEJtL,EAASC,OAAO,oBAChBsL,EAAW,uBAGf,OAFAF,EAAErL,GAAU,EACZuL,EAAS5L,MAAM,IAAI6L,SAAQ,SAAUC,GAAOH,EAAEG,GAAOA,CAAM,IACzB,IAA3BR,GAAQ,CAAA,EAAII,GAAGrL,IAAiB+K,GAAWE,GAAQ,CAAA,EAAIK,IAAIjG,KAAK,MAAQkG,CACjF,IAAK,SAAgBvF,EAAQ5E,GAM3B,IALA,IAAIsK,EAAIpQ,GAAS0K,GACb2F,EAAkB5Q,UAAUkE,OAC5B8I,EAAQ,EACRhI,EAAwBuJ,GAA4BnG,EACpDqD,EAAuBO,GAA2B5D,EAC/CwI,EAAkB5D,GAMvB,IALA,IAIIpM,EAJAiQ,EAAI/E,GAAc9L,UAAUgN,MAC5BhE,EAAOhE,EAAwBkJ,GAAO8B,GAAWa,GAAI7L,EAAsB6L,IAAMb,GAAWa,GAC5F3M,EAAS8E,EAAK9E,OACd4M,EAAI,EAED5M,EAAS4M,GACdlQ,EAAMoI,EAAK8H,KACNjQ,KAAelB,GAAK8L,EAAsBoF,EAAGjQ,KAAM+P,EAAE/P,GAAOiQ,EAAEjQ,IAErE,OAAO+P,CACX,EAAIT,GCtDAC,GAAS1P,GADL1B,GAMN,CAAEkM,OAAQ,SAAU4E,MAAM,EAAM/E,MAAO,EAAGiF,OAAQ/Q,OAAOmR,SAAWA,IAAU,CAC9EA,OAAQA,KCPV,IAGI/Q,GAAO,CAAA,EAEXA,GALsBL,GAEc,gBAGd,IAEtB,IAAAgS,GAAkC,eAAjB3N,OAAOhE,ICPpB4R,GAAwBjS,GACxB+C,GAAarB,EACbkL,GAAa/I,GAGbqO,GAFkB1L,GAEc,eAChCjF,GAAUtB,OAGVkS,GAAwE,cAApDvF,GAAW,WAAc,OAAO3L,SAAY,CAAjC,IAUnC4L,GAAiBoF,GAAwBrF,GAAa,SAAUzL,GAC9D,IAAImI,EAAG8I,EAAKxJ,EACZ,YAAc9F,IAAP3B,EAAmB,YAAqB,OAAPA,EAAc,OAEO,iBAAjDiR,EAXD,SAAUjR,EAAIU,GACzB,IACE,OAAOV,EAAGU,EACd,CAAI,MAAO/B,GAAsB,CACjC,CAOoBuS,CAAO/I,EAAI/H,GAAQJ,GAAK+Q,KAA8BE,EAEpED,GAAoBvF,GAAWtD,GAEF,YAA5BV,EAASgE,GAAWtD,KAAoBvG,GAAWuG,EAAEgJ,QAAU,YAAc1J,CACpF,EC3BIiE,GAAUnL,GCCVqC,GDFwB/D,GAKa,CAAA,EAAG+D,SAAW,WACrD,MAAO,WAAa8I,GAAQvJ,MAAQ,GACtC,ECP4BtD,IACR0B,GAMJzB,OAAOU,UAAW,WAAYoD,GAAU,CAAEqJ,QAAQ,ICPlE,IAGAmF,GAA6C,YAF/B7Q,GADD1B,EAGmByF,SCH5B8B,GAAcvH,EACd2G,GAAYjF,GCDZqB,GAAa/C,EAEb6E,GAAUR,OACVjD,GAAaC,UCFbmR,GFEa,SAAUxI,EAAQnI,EAAKqD,GACtC,IAEE,OAAOqC,GAAYZ,GAAU1G,OAAO+B,yBAAyBgI,EAAQnI,GAAKqD,IAC9E,CAAI,MAAOpF,GAAsB,CACjC,EENIgF,GAAWpD,GACX+Q,GDEa,SAAUhR,GACzB,GAAuB,iBAAZA,GAAwBsB,GAAWtB,GAAW,OAAOA,EAChE,MAAM,IAAIL,GAAW,aAAeyD,GAAQpD,GAAY,kBAC1D,ECCAiR,GAAiBzS,OAAO0S,iBAAmB,aAAe,CAAE,EAAG,WAC7D,IAEI7G,EAFA8G,GAAiB,EACjBvS,EAAO,CAAA,EAEX,KACEyL,EAAS0G,GAAoBvS,OAAOU,UAAW,YAAa,QACrDN,EAAM,IACbuS,EAAiBvS,aAAgBwS,KACrC,CAAI,MAAO/S,GAAsB,CAC/B,OAAO,SAAwBwJ,EAAGwJ,GAKhC,OAJAhO,GAASwE,GACTmJ,GAAmBK,GACfF,EAAgB9G,EAAOxC,EAAGwJ,GACzBxJ,EAAEyJ,UAAYD,EACZxJ,CACX,CACA,CAhB+D,QAgBzDxG,GCzBF5C,GAAiBF,EAA+CqJ,EAChEzH,GAASF,EAGTwQ,GAFkBrO,GAEc,eAEpCmP,GAAiB,SAAU9G,EAAQ+G,EAAKpC,GAClC3E,IAAW2E,IAAQ3E,EAASA,EAAOvL,WACnCuL,IAAWtK,GAAOsK,EAAQgG,KAC5BhS,GAAegM,EAAQgG,GAAe,CAAE5P,cAAc,EAAMkB,MAAOyP,GAEvE,ECXIjO,GAAahF,GACbiM,GAAwBvK,GAExBI,GAAc0E,EAEd0M,GAHkBrP,GAGQ,WCL1BwB,GAAgBrF,GAEhBoB,GAAaC,UAEjB8R,GAAiB,SAAUhS,EAAIiS,GAC7B,GAAI/N,GAAc+N,EAAWjS,GAAK,OAAOA,EACzC,MAAM,IAAIC,GAAW,uBACvB,ECPImG,GAAcvH,EACdJ,GAAQ8B,EACRqB,GAAac,EACbgJ,GAAUrG,GAEVxC,GAAgBgE,EAEhBqL,GAAO,WAAY,EACnBC,GAAQ,GACRC,GALazL,GAKU,UAAW,aAClC0L,GAAoB,2BACpB3T,GAAO0H,GAAYiM,GAAkB3T,MACrC4T,IAAuBD,GAAkBnT,KAAKgT,IAE9CK,GAAsB,SAAuBjS,GAC/C,IAAKsB,GAAWtB,GAAW,OAAO,EAClC,IAEE,OADA8R,GAAUF,GAAMC,GAAO7R,IAChB,CACR,CAAC,MAAO3B,GACP,OAAO,CACR,CACH,EAEI6T,GAAsB,SAAuBlS,GAC/C,IAAKsB,GAAWtB,GAAW,OAAO,EAClC,OAAQoL,GAAQpL,IACd,IAAK,gBACL,IAAK,oBACL,IAAK,yBAA0B,OAAO,EAExC,IAIE,OAAOgS,MAAyB5T,GAAK2T,GAAmBxP,GAAcvC,GACvE,CAAC,MAAO3B,GACP,OAAO,CACR,CACH,EAEA6T,GAAoBvN,MAAO,EAI3B,ICtBIwN,GAAWC,GAAOC,GAASC,GDsB/BC,IAAkBT,IAAa3T,IAAM,WACnC,IAAIqU,EACJ,OAAOP,GAAoBA,GAAoB9S,QACzC8S,GAAoBzT,UACpByT,IAAoB,WAAcO,GAAS,CAAK,KACjDA,CACP,IAAKN,GAAsBD,GEnDvBM,GAAgBhU,GAChB0G,GAAchF,GAEdN,GAAaC,UCHbyD,GAAW9E,GACXkU,GDKa,SAAUzS,GACzB,GAAIuS,GAAcvS,GAAW,OAAOA,EACpC,MAAM,IAAIL,GAAWsF,GAAYjF,GAAY,wBAC/C,ECPIP,GAAoB2C,EAGpBqP,GAFkB1M,GAEQ,WCL1BhG,GAAcR,EAEdS,GAAoBC,SAASC,UAC7BK,GAAQP,GAAkBO,MAC1BJ,GAAOH,GAAkBG,KAG7BuT,GAAmC,iBAAXC,SAAuBA,QAAQpT,QAAUR,GAAcI,GAAKN,KAAKU,IAAS,WAChG,OAAOJ,GAAKI,MAAMA,GAAOC,UAC3B,GCTI2L,GAAa5M,GACbuH,GAAc7F,ECDd6F,GDGa,SAAUxG,GAIzB,GAAuB,aAAnB6L,GAAW7L,GAAoB,OAAOwG,GAAYxG,EACxD,ECPI4F,GAAYjF,GACZlB,GAAcqD,EAEdvD,GAAOiH,GAAYA,GAAYjH,MAGnC+T,GAAiB,SAAUtT,EAAIuT,GAE7B,OADA3N,GAAU5F,QACM+B,IAATwR,EAAqBvT,EAAKP,GAAcF,GAAKS,EAAIuT,GAAQ,WAC9D,OAAOvT,EAAGC,MAAMsT,EAAMrT,UAC1B,CACA,ECVAsT,GAFiBvU,GAEW,WAAY,mBCAxCwU,GAFkBxU,EAEW,GAAGqL,OCF5BjK,GAAaC,UCGjBoT,GAAiB,qCAAqCpU,KAHtCL,ITAZkD,GAASlD,EACTgB,GAAQU,GACRpB,GAAOuD,GACPd,GAAayD,EACb5E,GAASkG,EACTlI,GAAQoI,EACRuM,GAAOlK,GACPmK,GAAalK,GACb9F,GAAgB0M,GAChBwD,GQPa,SAAUC,EAAQC,GACjC,GAAID,EAASC,EAAU,MAAM,IAAIxT,GAAW,wBAC5C,OAAOuT,CACT,ERKIE,GAASC,GACTC,GAAUC,GAEVtL,GAAMxG,GAAO+R,aACbC,GAAQhS,GAAOiS,eACf1P,GAAUvC,GAAOuC,QACjB2P,GAAWlS,GAAOkS,SAClB1U,GAAWwC,GAAOxC,SAClB2U,GAAiBnS,GAAOmS,eACxBhR,GAASnB,GAAOmB,OAChBiR,GAAU,EACVC,GAAQ,CAAA,EACRC,GAAqB,qBAGzB5V,IAAM,WAEJgU,GAAY1Q,GAAOuS,QACrB,IAEA,IAAIC,GAAM,SAAUlO,GAClB,GAAI5F,GAAO2T,GAAO/N,GAAK,CACrB,IAAIzG,EAAKwU,GAAM/N,UACR+N,GAAM/N,GACbzG,GACD,CACH,EAEI4U,GAAS,SAAUnO,GACrB,OAAO,WACLkO,GAAIlO,EACR,CACA,EAEIoO,GAAgB,SAAUC,GAC5BH,GAAIG,EAAM9F,KACZ,EAEI+F,GAAyB,SAAUtO,GAErCtE,GAAO6S,YAAY1R,GAAOmD,GAAKoM,GAAUoC,SAAW,KAAOpC,GAAUqC,KACvE,EAGKvM,IAAQwL,KACXxL,GAAM,SAAsBwM,GAC1BxB,GAAwBzT,UAAUkE,OAAQ,GAC1C,IAAIpE,EAAKgC,GAAWmT,GAAWA,EAAUxV,GAASwV,GAC9CC,EAAO3B,GAAWvT,UAAW,GAKjC,OAJAsU,KAAQD,IAAW,WACjBtU,GAAMD,OAAI+B,EAAWqT,EAC3B,EACItC,GAAMyB,IACCA,EACX,EACEJ,GAAQ,SAAwB1N,UACvB+N,GAAM/N,EACjB,EAEMuN,GACFlB,GAAQ,SAAUrM,GAChB/B,GAAQ2Q,SAAST,GAAOnO,GAC9B,EAEa4N,IAAYA,GAASiB,IAC9BxC,GAAQ,SAAUrM,GAChB4N,GAASiB,IAAIV,GAAOnO,GAC1B,EAGa6N,KAAmBR,IAE5Bd,IADAD,GAAU,IAAIuB,IACCiB,MACfxC,GAAQyC,MAAMC,UAAYZ,GAC1B/B,GAAQvT,GAAKyT,GAAKgC,YAAahC,KAI/B7Q,GAAOuT,kBACP1T,GAAWG,GAAO6S,eACjB7S,GAAOwT,eACR9C,IAAoC,UAAvBA,GAAUoC,WACtBpW,GAAMkW,KAEPjC,GAAQiC,GACR5S,GAAOuT,iBAAiB,UAAWb,IAAe,IAGlD/B,GADS2B,MAAsBhR,GAAc,UACrC,SAAUgD,GAChB+M,GAAKoC,YAAYnS,GAAc,WAAWgR,IAAsB,WAC9DjB,GAAKqC,YAAYtT,MACjBoS,GAAIlO,EACZ,CACA,EAGY,SAAUA,GAChBqP,WAAWlB,GAAOnO,GAAK,EAC7B,GAIA,IAAAsP,GAAiB,CACfpN,IAAKA,GACLwL,MAAOA,IUlHL6B,GAAQ,WACVzT,KAAK0T,KAAO,KACZ1T,KAAK2T,KAAO,IACd,EAEAF,GAAMpW,UAAY,CAChBuW,IAAK,SAAUC,GACb,IAAIC,EAAQ,CAAED,KAAMA,EAAME,KAAM,MAC5BJ,EAAO3T,KAAK2T,KACZA,EAAMA,EAAKI,KAAOD,EACjB9T,KAAK0T,KAAOI,EACjB9T,KAAK2T,KAAOG,CACb,EACDjX,IAAK,WACH,IAAIiX,EAAQ9T,KAAK0T,KACjB,GAAII,EAGF,OADa,QADF9T,KAAK0T,KAAOI,EAAMC,QACV/T,KAAK2T,KAAO,MACxBG,EAAMD,IAEhB,GAGH,ICNIG,GAAQC,GAAQC,GAAMC,GAASC,GDMnCnC,GAAiBwB,GErBjBY,GAAiB,oBAAoBtX,KAFrBL,KAEyD,oBAAV4X,OCA/DC,GAAiB,qBAAqBxX,KAFtBL,IFAZkD,GAASlD,EACTM,GAAOoB,GACPM,GAA2B6B,GAA2DwF,EACtFyO,GAAYtR,GAA6BkD,IACzCqN,GAAQjP,GACR+M,GAAS7M,GACT+P,GAAgB1N,GAChB2N,GAAkB1N,GAClByK,GAAU7D,GAEV+G,GAAmB/U,GAAO+U,kBAAoB/U,GAAOgV,uBACrDxV,GAAWQ,GAAOR,SAClB+C,GAAUvC,GAAOuC,QACjB0S,GAAUjV,GAAOiV,QAEjBC,GAA2BpW,GAAyBkB,GAAQ,kBAC5DmV,GAAYD,IAA4BA,GAAyB5U,MAIrE,IAAK6U,GAAW,CACd,IAAI9C,GAAQ,IAAIwB,GAEZuB,GAAQ,WACV,IAAIC,EAAQxX,EAEZ,IADIgU,KAAYwD,EAAS9S,GAAQ+S,SAASD,EAAOE,OAC1C1X,EAAKwU,GAAMpV,WAChBY,GACD,CAAC,MAAOjB,GAEP,MADIyV,GAAMyB,MAAMM,KACVxX,CACP,CACGyY,GAAQA,EAAOG,OACvB,EAIO7D,IAAWE,IAAYiD,KAAmBC,KAAoBvV,IAQvDqV,IAAiBI,IAAWA,GAAQQ,UAE9ClB,GAAUU,GAAQQ,aAAQ7V,IAElBkJ,YAAcmM,GACtBT,GAAOpX,GAAKmX,GAAQC,KAAMD,IAC1BH,GAAS,WACPI,GAAKY,GACX,GAEavD,GACTuC,GAAS,WACP7R,GAAQ2Q,SAASkC,GACvB,GASIR,GAAYxX,GAAKwX,GAAW5U,IAC5BoU,GAAS,WACPQ,GAAUQ,GAChB,IAhCIf,IAAS,EACTC,GAAO9U,GAASkW,eAAe,IAC/B,IAAIX,GAAiBK,IAAOO,QAAQrB,GAAM,CAAEsB,eAAe,IAC3DxB,GAAS,WACPE,GAAKzH,KAAOwH,IAAUA,EAC5B,GA8BEc,GAAY,SAAUtX,GACfwU,GAAMyB,MAAMM,KACjB/B,GAAM2B,IAAInW,EACd,CACA,CAEA,IAAAgY,GAAiBV,GG/EjBW,GAAiB,SAAUnZ,GACzB,IACE,MAAO,CAAEC,OAAO,EAAO0D,MAAO3D,IAC/B,CAAC,MAAOC,GACP,MAAO,CAAEA,OAAO,EAAM0D,MAAO1D,EAC9B,CACH,ECJAmZ,GAFajZ,EAEWmY,QCDxBe,GAAgC,iBAARxT,MAAoBA,MAA+B,iBAAhBA,KAAKxB,QCEhEiV,IAHcnZ,KACA0B,IAGQ,iBAAV0B,QACY,iBAAZV,SCLRQ,GAASlD,EACToZ,GAA2B1X,GAC3BqB,GAAac,EACb+L,GAAWpJ,GACXxC,GAAgB8D,EAChBM,GAAkBJ,GAClBqR,GAAahP,GACbiP,GAAUhP,GAEVvE,GAAawT,GAEYH,IAA4BA,GAAyBzY,UAClF,IAAIuS,GAAU9K,GAAgB,WAC1BoR,IAAc,EACdC,GAAiC1W,GAAWG,GAAOwW,uBAEnDC,GAA6B/J,GAAS,WAAW,WACnD,IAAIgK,EAA6B5V,GAAcoV,IAC3CS,EAAyBD,IAA+BvV,OAAO+U,IAInE,IAAKS,GAAyC,KAAf9T,GAAmB,OAAO,EAMzD,IAAKA,IAAcA,GAAa,KAAO,cAAc1F,KAAKuZ,GAA6B,CAErF,IAAInC,EAAU,IAAI2B,IAAyB,SAAUT,GAAWA,EAAQ,EAAG,IACvEmB,EAAc,SAAUja,GAC1BA,GAAK,WAAY,IAAiB,WAAY,GACpD,EAII,IAHkB4X,EAAQzL,YAAc,IAC5BkH,IAAW4G,IACvBN,GAAc/B,EAAQC,MAAK,WAA2B,cAAaoC,GACjD,OAAO,CAE7B,CAAI,OAAQD,IAA2BR,IAAcC,MAAaG,EAClE,IAEAM,GAAiB,CACfC,YAAaL,GACbM,gBAAiBR,GACjBD,YAAaA,IC7CfU,GAAA,CAAA,EAAIvT,GAAY3G,GAEZoB,GAAaC,UAEb8Y,GAAoB,SAAUC,GAChC,IAAIzB,EAAS0B,EACb/W,KAAKmU,QAAU,IAAI2C,GAAE,SAAUE,EAAWC,GACxC,QAAgBzX,IAAZ6V,QAAoC7V,IAAXuX,EAAsB,MAAM,IAAIjZ,GAAW,2BACxEuX,EAAU2B,EACVD,EAASE,CACb,IACEjX,KAAKqV,QAAUhS,GAAUgS,GACzBrV,KAAK+W,OAAS1T,GAAU0T,EAC1B,EAIgBG,GAAAnR,EAAG,SAAU+Q,GAC3B,OAAO,IAAID,GAAkBC,EAC/B,ECnBA,IAgDIK,GAAUC,GAAsCC,GAhDhDC,GAAI5a,GAEJ+U,GAAUlR,GACVX,GAASsD,EACT5F,GAAOkH,GACPoF,GAAgBlF,GAChB2K,GAAiBtI,GACjB2I,GAAiB1I,GACjBuQ,GvBDa,SAAUC,GACzB,IAAIC,EAAc/V,GAAW8V,GAEzBhZ,IAAeiZ,IAAgBA,EAAY7H,KAC7CjH,GAAsB8O,EAAa7H,GAAS,CAC1C5Q,cAAc,EACdnC,IAAK,WAAc,OAAOmD,IAAO,GAGvC,EuBPIqD,GAAY4S,GACZxW,GAAa+R,EACbxQ,GAAW0Q,EACX7B,GAAa6H,GACbC,GlBJa,SAAU3R,EAAG4R,GAC5B,IACIpJ,EADAsI,EAAItV,GAASwE,GAAG0C,YAEpB,YAAalJ,IAANsX,GAAmBlZ,GAAkB4Q,EAAIhN,GAASsV,GAAGlH,KAAYgI,EAAqBhH,GAAapC,EAC5G,EkBCIgF,GAAOqE,GAA6BzR,IACpC2O,GAAY+C,GACZC,GChBa,SAAU1W,EAAG2M,GAC5B,IAEuB,IAArBrQ,UAAUkE,OAAemW,QAAQxb,MAAM6E,GAAK2W,QAAQxb,MAAM6E,EAAG2M,EACjE,CAAI,MAAOxR,GAAsB,CACjC,EDYIkZ,GAAUuC,GACVxE,GAAQyE,GACRC,GAAsBC,GACtBtC,GAA2BuC,GAE3BC,GAA6BC,GAE7BC,GAAU,UACVnC,GAJ8BoC,GAI2B/B,YACzDP,GAL8BsC,GAK+B9B,gBAC7D+B,GAN8BD,GAM2BvC,YACzDyC,GAA0BR,GAAoB3Q,UAAUgR,IACxDI,GAAmBT,GAAoB/R,IACvCyS,GAAyB/C,IAA4BA,GAAyBzY,UAC9Eyb,GAAqBhD,GACrBiD,GAAmBF,GACnB9a,GAAY6B,GAAO7B,UACnBqB,GAAWQ,GAAOR,SAClB+C,GAAUvC,GAAOuC,QACjB+U,GAAuBoB,GAA2BvS,EAClDiT,GAA8B9B,GAE9B+B,MAAoB7Z,IAAYA,GAAS8Z,aAAetZ,GAAOuZ,eAC/DC,GAAsB,qBAWtBC,GAAa,SAAUxb,GACzB,IAAIuW,EACJ,SAAOpT,GAASnD,KAAO4B,GAAW2U,EAAOvW,EAAGuW,QAAQA,CACtD,EAEIkF,GAAe,SAAUC,EAAUrS,GACrC,IAMI5B,EAAQ8O,EAAMoF,EANdtZ,EAAQgH,EAAMhH,MACduZ,EAfU,IAeLvS,EAAMA,MACX0L,EAAU6G,EAAKF,EAASE,GAAKF,EAASG,KACtCrE,EAAUkE,EAASlE,QACnB0B,EAASwC,EAASxC,OAClB7B,EAASqE,EAASrE,OAEtB,IACMtC,GACG6G,IApBK,IAqBJvS,EAAMyS,WAAyBC,GAAkB1S,GACrDA,EAAMyS,UAvBA,IAyBQ,IAAZ/G,EAAkBtN,EAASpF,GAEzBgV,GAAQA,EAAOE,QACnB9P,EAASsN,EAAQ1S,GACbgV,IACFA,EAAOC,OACPqE,GAAS,IAGTlU,IAAWiU,EAASpF,QACtB4C,EAAO,IAAIhZ,GAAU,yBACZqW,EAAOiF,GAAW/T,IAC3BhI,GAAK8W,EAAM9O,EAAQ+P,EAAS0B,GACvB1B,EAAQ/P,IACVyR,EAAO7W,EACf,CAAC,MAAO1D,GACH0Y,IAAWsE,GAAQtE,EAAOC,OAC9B4B,EAAOva,EACR,CACH,EAEIwX,GAAS,SAAU9M,EAAO2S,GACxB3S,EAAM4S,WACV5S,EAAM4S,UAAW,EACjB/E,IAAU,WAGR,IAFA,IACIwE,EADAQ,EAAY7S,EAAM6S,UAEfR,EAAWQ,EAAUld,OAC1Byc,GAAaC,EAAUrS,GAEzBA,EAAM4S,UAAW,EACbD,IAAa3S,EAAMyS,WAAWK,GAAY9S,EAClD,IACA,EAEIiS,GAAgB,SAAUra,EAAMqV,EAAS8F,GAC3C,IAAI1H,EAAOK,EACPqG,KACF1G,EAAQnT,GAAS8Z,YAAY,UACvB/E,QAAUA,EAChB5B,EAAM0H,OAASA,EACf1H,EAAM2H,UAAUpb,GAAM,GAAO,GAC7Bc,GAAOuZ,cAAc5G,IAChBA,EAAQ,CAAE4B,QAASA,EAAS8F,OAAQA,IACtC9D,KAAmCvD,EAAUhT,GAAO,KAAOd,IAAQ8T,EAAQL,GACvEzT,IAASsa,IAAqBrB,GAAiB,8BAA+BkC,EACzF,EAEID,GAAc,SAAU9S,GAC1B5J,GAAKkW,GAAM5T,IAAQ,WACjB,IAGI0F,EAHA6O,EAAUjN,EAAME,OAChBlH,EAAQgH,EAAMhH,MAGlB,GAFmBia,GAAYjT,KAG7B5B,EAASoQ,IAAQ,WACXjE,GACFtP,GAAQiY,KAAK,qBAAsBla,EAAOiU,GACrCgF,GAAcC,GAAqBjF,EAASjU,EAC3D,IAEMgH,EAAMyS,UAAYlI,IAAW0I,GAAYjT,GArF/B,EADF,EAuFJ5B,EAAO9I,OAAO,MAAM8I,EAAOpF,KAErC,GACA,EAEIia,GAAc,SAAUjT,GAC1B,OA7FY,IA6FLA,EAAMyS,YAA0BzS,EAAM+N,MAC/C,EAEI2E,GAAoB,SAAU1S,GAChC5J,GAAKkW,GAAM5T,IAAQ,WACjB,IAAIuU,EAAUjN,EAAME,OAChBqK,GACFtP,GAAQiY,KAAK,mBAAoBjG,GAC5BgF,GAzGa,mBAyGoBhF,EAASjN,EAAMhH,MAC3D,GACA,EAEIlD,GAAO,SAAUS,EAAIyJ,EAAOmT,GAC9B,OAAO,SAAUna,GACfzC,EAAGyJ,EAAOhH,EAAOma,EACrB,CACA,EAEIC,GAAiB,SAAUpT,EAAOhH,EAAOma,GACvCnT,EAAMqT,OACVrT,EAAMqT,MAAO,EACTF,IAAQnT,EAAQmT,GACpBnT,EAAMhH,MAAQA,EACdgH,EAAMA,MArHO,EAsHb8M,GAAO9M,GAAO,GAChB,EAEIsT,GAAkB,SAAUtT,EAAOhH,EAAOma,GAC5C,IAAInT,EAAMqT,KAAV,CACArT,EAAMqT,MAAO,EACTF,IAAQnT,EAAQmT,GACpB,IACE,GAAInT,EAAME,SAAWlH,EAAO,MAAM,IAAInC,GAAU,oCAChD,IAAIqW,EAAOiF,GAAWnZ,GAClBkU,EACFW,IAAU,WACR,IAAI0F,EAAU,CAAEF,MAAM,GACtB,IACEjd,GAAK8W,EAAMlU,EACTlD,GAAKwd,GAAiBC,EAASvT,GAC/BlK,GAAKsd,GAAgBG,EAASvT,GAEjC,CAAC,MAAO1K,GACP8d,GAAeG,EAASje,EAAO0K,EAChC,CACT,KAEMA,EAAMhH,MAAQA,EACdgH,EAAMA,MA/II,EAgJV8M,GAAO9M,GAAO,GAEjB,CAAC,MAAO1K,GACP8d,GAAe,CAAEC,MAAM,GAAS/d,EAAO0K,EACxC,CAzBsB,CA0BzB,EAGA,GAAImP,KAcF0C,IAZAD,GAAqB,SAAiB4B,GACpC7K,GAAW7P,KAAM+Y,IACjB1V,GAAUqX,GACVpd,GAAK6Z,GAAUnX,MACf,IAAIkH,EAAQyR,GAAwB3Y,MACpC,IACE0a,EAAS1d,GAAKwd,GAAiBtT,GAAQlK,GAAKsd,GAAgBpT,GAC7D,CAAC,MAAO1K,GACP8d,GAAepT,EAAO1K,EACvB,CACL,GAEwCa,WAGtC8Z,GAAW,SAAiBuD,GAC1B9B,GAAiB5Y,KAAM,CACrB0H,KAAM8Q,GACN+B,MAAM,EACNT,UAAU,EACV7E,QAAQ,EACR8E,UAAW,IAAItG,GACfkG,WAAW,EACXzS,MAlLQ,EAmLRhH,WAAOV,GAEb,GAIWnC,UAAYuM,GAAcmP,GAAkB,QAAQ,SAAc4B,EAAaC,GACtF,IAAI1T,EAAQyR,GAAwB3Y,MAChCuZ,EAAWrC,GAAqBS,GAAmB3X,KAAM8Y,KAS7D,OARA5R,EAAM+N,QAAS,EACfsE,EAASE,IAAKha,GAAWkb,IAAeA,EACxCpB,EAASG,KAAOja,GAAWmb,IAAeA,EAC1CrB,EAASrE,OAASzD,GAAUtP,GAAQ+S,YAAS1V,EA/LnC,IAgMN0H,EAAMA,MAAmBA,EAAM6S,UAAUnG,IAAI2F,GAC5CxE,IAAU,WACbuE,GAAaC,EAAUrS,EAC7B,IACWqS,EAASpF,OACpB,IAEEiD,GAAuB,WACrB,IAAIjD,EAAU,IAAIgD,GACdjQ,EAAQyR,GAAwBxE,GACpCnU,KAAKmU,QAAUA,EACfnU,KAAKqV,QAAUrY,GAAKwd,GAAiBtT,GACrClH,KAAK+W,OAAS/Z,GAAKsd,GAAgBpT,EACvC,EAEEoR,GAA2BvS,EAAImR,GAAuB,SAAUJ,GAC9D,OAAOA,IAAMgC,IA1MmB+B,YA0MG/D,EAC/B,IAAIM,GAAqBN,GACzBkC,GAA4BlC,EACpC,EAEkBrX,GAAWqW,KAA6B+C,KAA2Blc,OAAOU,WAAW,CACnGga,GAAawB,GAAuBzE,KAE/BsE,IAEH9O,GAAciP,GAAwB,QAAQ,SAAc8B,EAAaC,GACvE,IAAI5J,EAAOhR,KACX,OAAO,IAAI8Y,IAAmB,SAAUzD,EAAS0B,GAC/CzZ,GAAK+Z,GAAYrG,EAAMqE,EAAS0B,EACjC,IAAE3C,KAAKuG,EAAaC,EAE7B,GAAS,CAAE9Q,QAAQ,IAIf,WACS+O,GAAuBnQ,WACpC,CAAM,MAAOlM,GAAsB,CAG3B6S,IACFA,GAAewJ,GAAwBE,GAE1C,CAGHzB,GAAE,CAAE1X,QAAQ,EAAM8I,aAAa,EAAMoS,MAAM,EAAMpN,OAAQ2I,IAA8B,CACrFxB,QAASiE,KAGXpJ,GAAeoJ,GAAoBN,IAAS,GAC5CjB,GAAWiB,IE9RX,IAAAuC,GAAiB,CAAA,ECCbC,GAAY5c,GAEZ6c,GAHkBve,GAGS,YAC3Bwe,GAAiB3L,MAAMlS,UCJvBkM,GAAU7M,GACV4G,GAAYlF,GACZR,GAAoB2C,EACpBya,GAAY9X,GAGZ+X,GAFkBzW,GAES,YAE/B2W,GAAiB,SAAUtd,GACzB,IAAKD,GAAkBC,GAAK,OAAOyF,GAAUzF,EAAIod,KAC5C3X,GAAUzF,EAAI,eACdmd,GAAUzR,GAAQ1L,GACzB,ECZIP,GAAOZ,GACP2G,GAAYjF,GACZoD,GAAWjB,GACX6C,GAAcF,GACdiY,GAAoB3W,GAEpB1G,GAAaC,UCNbT,GAAOZ,GACP8E,GAAWpD,GACXkF,GAAY/C,GCFZvD,GAAON,GACPY,GAAOc,GACPoD,GAAWjB,GACX6C,GAAcF,GACdkY,GJGa,SAAUvd,GACzB,YAAc2B,IAAP3B,IAAqBmd,GAAUzL,QAAU1R,GAAMqd,GAAeD,MAAcpd,EACrF,EIJIiN,GAAoBpG,GACpB3C,GAAgBgF,GAChBsU,GFCa,SAAUld,EAAUmd,GACnC,IAAIC,EAAiB5d,UAAUkE,OAAS,EAAIsZ,GAAkBhd,GAAYmd,EAC1E,GAAIjY,GAAUkY,GAAiB,OAAO/Z,GAASlE,GAAKie,EAAgBpd,IACpE,MAAM,IAAIL,GAAWsF,GAAYjF,GAAY,mBAC/C,EEJIgd,GAAoBvN,GACpB4N,GDLa,SAAUxY,EAAUyY,EAAMvb,GACzC,IAAIwb,EAAaC,EACjBna,GAASwB,GACT,IAEE,KADA0Y,EAAcpY,GAAUN,EAAU,WAChB,CAChB,GAAa,UAATyY,EAAkB,MAAMvb,EAC5B,OAAOA,CACR,CACDwb,EAAcpe,GAAKoe,EAAa1Y,EACjC,CAAC,MAAOxG,GACPmf,GAAa,EACbD,EAAclf,CACf,CACD,GAAa,UAATif,EAAkB,MAAMvb,EAC5B,GAAIyb,EAAY,MAAMD,EAEtB,OADAla,GAASka,GACFxb,CACT,ECXIpC,GAAaC,UAEb6d,GAAS,SAAUC,EAASvW,GAC9BtF,KAAK6b,QAAUA,EACf7b,KAAKsF,OAASA,CAChB,EAEIwW,GAAkBF,GAAOve,UAE7B0e,GAAiB,SAAUC,EAAUC,EAAiB3T,GACpD,IAMItF,EAAUkZ,EAAQvR,EAAO9I,EAAQyD,EAAQyO,EAAMoI,EAN/CnL,EAAO1I,GAAWA,EAAQ0I,KAC1BoL,KAAgB9T,IAAWA,EAAQ8T,YACnCC,KAAe/T,IAAWA,EAAQ+T,WAClCC,KAAiBhU,IAAWA,EAAQgU,aACpCC,KAAiBjU,IAAWA,EAAQiU,aACpC9e,EAAKT,GAAKif,EAAiBjL,GAG3BwL,EAAO,SAAUC,GAEnB,OADIzZ,GAAUwY,GAAcxY,EAAU,SAAUyZ,GACzC,IAAIb,IAAO,EAAMa,EAC5B,EAEMC,EAAS,SAAUxc,GACrB,OAAIkc,GACF5a,GAAStB,GACFqc,EAAc9e,EAAGyC,EAAM,GAAIA,EAAM,GAAIsc,GAAQ/e,EAAGyC,EAAM,GAAIA,EAAM,KAChEqc,EAAc9e,EAAGyC,EAAOsc,GAAQ/e,EAAGyC,EAChD,EAEE,GAAImc,EACFrZ,EAAWgZ,EAAShZ,cACf,GAAIsZ,EACTtZ,EAAWgZ,MACN,CAEL,KADAE,EAASf,GAAkBa,IACd,MAAM,IAAIle,GAAWsF,GAAY4Y,GAAY,oBAE1D,GAAIZ,GAAsBc,GAAS,CACjC,IAAKvR,EAAQ,EAAG9I,EAASiJ,GAAkBkR,GAAWna,EAAS8I,EAAOA,IAEpE,IADArF,EAASoX,EAAOV,EAASrR,MACX5I,GAAc+Z,GAAiBxW,GAAS,OAAOA,EAC7D,OAAO,IAAIsW,IAAO,EACrB,CACD5Y,EAAWqY,GAAYW,EAAUE,EAClC,CAGD,IADAnI,EAAOsI,EAAYL,EAASjI,KAAO/Q,EAAS+Q,OACnCoI,EAAO7e,GAAKyW,EAAM/Q,IAAWuX,MAAM,CAC1C,IACEjV,EAASoX,EAAOP,EAAKjc,MACtB,CAAC,MAAO1D,GACPgf,GAAcxY,EAAU,QAASxG,EAClC,CACD,GAAqB,iBAAV8I,GAAsBA,GAAUvD,GAAc+Z,GAAiBxW,GAAS,OAAOA,CAC9F,CAAI,OAAO,IAAIsW,IAAO,EACtB,ECjEIX,GAFkBve,GAES,YAC3BigB,IAAe,EAEnB,IACE,IAAIhM,GAAS,EACTiM,GAAqB,CACvB7I,KAAM,WACJ,MAAO,CAAEwG,OAAQ5J,KAClB,EACDkM,OAAU,WACRF,IAAe,CAChB,GAEHC,GAAmB3B,IAAY,WAC7B,OAAOjb,IACX,EAEEuP,MAAMuN,KAAKF,IAAoB,WAAc,MAAM,CAAE,GACvD,CAAE,MAAOpgB,GAAsB,CAE/B,IAAAugB,GAAiB,SAAUxgB,EAAMygB,GAC/B,IACE,IAAKA,IAAiBL,GAAc,OAAO,CAC5C,CAAC,MAAOngB,GAAS,OAAO,CAAQ,CACjC,IAAIygB,GAAoB,EACxB,IACE,IAAIvW,EAAS,CAAA,EACbA,EAAOuU,IAAY,WACjB,MAAO,CACLlH,KAAM,WACJ,MAAO,CAAEwG,KAAM0C,GAAoB,EACpC,EAET,EACI1gB,EAAKmK,EACT,CAAI,MAAOlK,GAAsB,CAC/B,OAAOygB,CACT,ECvCInH,GAA2BpZ,GAI/BwgB,GAFiC3c,GAAsDmW,cADrDtY,IAG0C,SAAU4d,GACpFlG,GAAyBzW,IAAI2c,GAAU5H,UAAK5U,GAAW,WAAY,GACrE,ICLIlC,GAAOc,GACPiF,GAAY9C,GACZ+X,GAA6BpV,GAC7BwS,GAAUlR,GACVuX,GAAUrX,GALNhI,GAUN,CAAEkM,OAAQ,UAAW4E,MAAM,EAAME,OAJO3G,IAIwC,CAChF1H,IAAK,SAAa2c,GAChB,IAAIlF,EAAI9W,KACJmd,EAAa7E,GAA2BvS,EAAE+Q,GAC1CzB,EAAU8H,EAAW9H,QACrB0B,EAASoG,EAAWpG,OACpBzR,EAASoQ,IAAQ,WACnB,IAAI0H,EAAkB/Z,GAAUyT,EAAEzB,SAC9BgI,EAAS,GACTrL,EAAU,EACVsL,EAAY,EAChBvB,GAAQC,GAAU,SAAU7H,GAC1B,IAAIxJ,EAAQqH,IACRuL,GAAgB,EACpBD,IACAhgB,GAAK8f,EAAiBtG,EAAG3C,GAASC,MAAK,SAAUlU,GAC3Cqd,IACJA,GAAgB,EAChBF,EAAO1S,GAASzK,IACdod,GAAajI,EAAQgI,GACxB,GAAEtG,EACX,MACQuG,GAAajI,EAAQgI,EAC7B,IAEI,OADI/X,EAAO9I,OAAOua,EAAOzR,EAAOpF,OACzBid,EAAWhJ,OACnB,ICpCH,IAAImD,GAAI5a,GAEJ2Z,GAA6B9V,GAAsDmW,YACnFZ,GAA2B5S,GAC3BxB,GAAa8C,GACb/E,GAAaiF,EACbkF,GAAgB7C,GAEhB8R,GAAyB/C,IAA4BA,GAAyBzY,UAWlF,GAPAia,GAAE,CAAE1O,OAAQ,UAAW4G,OAAO,EAAM9B,OAAQ2I,GAA4BmH,MAAM,GAAQ,CACpFC,MAAS,SAAU7C,GACjB,OAAO5a,KAAKoU,UAAK5U,EAAWob,EAC7B,IAIanb,GAAWqW,IAA2B,CACpD,IAAIlU,GAASF,GAAW,WAAWrE,UAAiB,MAChDwb,GAA8B,QAAMjX,IACtCgI,GAAciP,GAAwB,QAASjX,GAAQ,CAAEkI,QAAQ,GAErE,CCxBA,IACIxM,GAAOc,GACPiF,GAAY9C,GACZ+X,GAA6BpV,GAC7BwS,GAAUlR,GACVuX,GAAUrX,GALNhI,GAUN,CAAEkM,OAAQ,UAAW4E,MAAM,EAAME,OAJO3G,IAIwC,CAChF2W,KAAM,SAAc1B,GAClB,IAAIlF,EAAI9W,KACJmd,EAAa7E,GAA2BvS,EAAE+Q,GAC1CC,EAASoG,EAAWpG,OACpBzR,EAASoQ,IAAQ,WACnB,IAAI0H,EAAkB/Z,GAAUyT,EAAEzB,SAClC0G,GAAQC,GAAU,SAAU7H,GAC1B7W,GAAK8f,EAAiBtG,EAAG3C,GAASC,KAAK+I,EAAW9H,QAAS0B,EACnE,GACA,IAEI,OADIzR,EAAO9I,OAAOua,EAAOzR,EAAOpF,OACzBid,EAAWhJ,OACnB,ICvBH,IACI7W,GAAOc,GACPka,GAA6B/X,GAFzB7D,GAON,CAAEkM,OAAQ,UAAW4E,MAAM,EAAME,OAJFxK,GAAsDwT,aAId,CACvEK,OAAQ,SAAgB4G,GACtB,IAAIR,EAAa7E,GAA2BvS,EAAE/F,MAE9C,OADA1C,GAAK6f,EAAWpG,YAAQvX,EAAWme,GAC5BR,EAAWhJ,OACnB,ICZH,IAAI3S,GAAW9E,GACXsE,GAAW5C,EACX8Y,GAAuB3W,GCFvB+W,GAAI5a,GAIJ2Z,GAA6B7R,GAAsDkS,YACnFkH,GDDa,SAAU9G,EAAG1M,GAE5B,GADA5I,GAASsV,GACL9V,GAASoJ,IAAMA,EAAE1B,cAAgBoO,EAAG,OAAO1M,EAC/C,IAAIyT,EAAoB3G,GAAqBnR,EAAE+Q,GAG/C,OADAzB,EADcwI,EAAkBxI,SACxBjL,GACDyT,EAAkB1J,OAC3B,ECViB/V,GAM0B,WAK3CkZ,GAAE,CAAE1O,OAAQ,UAAW4E,MAAM,EAAME,OAAmB2I,IAA8B,CAClFhB,QAAS,SAAiBjL,GACxB,OAAOwT,GAAgG5d,KAAMoK,EAC9G,ICfH,IAAI9N,GAAQI,EAEZohB,GAAiB,SAAUC,EAAa5f,GACtC,IAAIyD,EAAS,GAAGmc,GAChB,QAASnc,GAAUtF,IAAM,WAEvBsF,EAAOtE,KAAK,KAAMa,GAAY,WAAc,OAAO,GAAM,EAC7D,GACA,ECRImZ,GAAI5a,GAEJ+M,GAAgBlJ,GAChBmJ,GAAkBxG,GAClB4a,GAAsBtZ,GAEtBwZ,GALc5f,EAKW,GAAG6J,MAOhCqP,GAAE,CAAE1O,OAAQ,QAAS4G,OAAO,EAAM9B,OALhBjE,KAAkB9M,SACPmhB,GAAoB,OAAQ,MAIL,CAClD7V,KAAM,SAAcgW,GAClB,OAAOD,GAAWtU,GAAgB1J,WAAqBR,IAAdye,EAA0B,IAAMA,EAC1E,IChBH,IAAAC,GAAA,CAAA,EAAI1f,GAAc9B,EACdgJ,GAA0BtH,GAC1BoI,GAAuBjG,EACvBiB,GAAW0B,GACXwG,GAAkBlF,GAClBmJ,GAAajJ,GAKjBwZ,GAAAnY,EAAYvH,KAAgBkH,GAA0B/I,OAAOwhB,iBAAmB,SAA0BnY,EAAGoY,GAC3G5c,GAASwE,GAMT,IALA,IAIIzH,EAJA8f,EAAQ3U,GAAgB0U,GACxBzX,EAAOgH,GAAWyQ,GAClBvc,EAAS8E,EAAK9E,OACd8I,EAAQ,EAEL9I,EAAS8I,GAAOnE,GAAqBT,EAAEC,EAAGzH,EAAMoI,EAAKgE,KAAU0T,EAAM9f,IAC5E,OAAOyH,CACT,EClBA,IAmDIsY,GAnDA9c,GAAW9E,GACX6hB,GAAyBngB,GACzBuN,GAAcpL,GACdsG,GAAa3D,GACb+N,GAAOzM,GACPrD,GAAwBuD,GAKxB8Z,GAAY,YACZC,GAAS,SACTC,GANY3X,GAMS,YAErB4X,GAAmB,WAAY,EAE/BC,GAAY,SAAUC,GACxB,MARO,IAQKJ,GATL,IASmBI,EAAnBC,KAAwCL,GATxC,GAUT,EAGIM,GAA4B,SAAUT,GACxCA,EAAgBU,MAAMJ,GAAU,KAChCN,EAAgBW,QAChB,IAAIC,EAAOZ,EAAgBa,aAAaxiB,OAExC,OADA2hB,EAAkB,KACXY,CACT,EAyBIE,GAAkB,WACpB,IACEd,GAAkB,IAAIe,cAAc,WACxC,CAAI,MAAO7iB,GAAuB,CAzBH,IAIzB8iB,EAFAC,EACAC,EAuBJJ,GAAqC,oBAAZhgB,SACrBA,SAAS8V,QAAUoJ,GACjBS,GAA0BT,KA1B5BiB,EAASpe,GAAsB,UAC/Bqe,EAAK,OAASf,GAAS,IAE3Bc,EAAOE,MAAMC,QAAU,OACvBzO,GAAKoC,YAAYkM,GAEjBA,EAAOI,IAAM5e,OAAOye,IACpBF,EAAiBC,EAAOK,cAAcxgB,UACvBygB,OACfP,EAAeN,MAAMJ,GAAU,sBAC/BU,EAAeL,QACRK,EAAeQ,GAiBlBf,GAA0BT,IAE9B,IADA,IAAIzc,EAAS8J,GAAY9J,OAClBA,YAAiBud,GAAgBZ,IAAW7S,GAAY9J,IAC/D,OAAOud,IACT,EAEAvY,GAAW6X,KAAY,MAKvBqB,GAAiBpjB,OAAOqjB,QAAU,SAAgBha,EAAGoY,GACnD,IAAI9Y,EAQJ,OAPU,OAANU,GACF2Y,GAAiBH,IAAahd,GAASwE,GACvCV,EAAS,IAAIqZ,GACbA,GAAiBH,IAAa,KAE9BlZ,EAAOoZ,IAAY1Y,GACdV,EAAS8Z,UACM5f,IAAf4e,EAA2B9Y,EAASiZ,GAAuBxY,EAAET,EAAQ8Y,EAC9E,EClFItZ,GAAkBpI,GAClBsjB,GAAS5hB,GACTxB,GAAiB2D,EAA+CwF,EAEhEka,GAAcnb,GAAgB,eAC9BoW,GAAiB3L,MAAMlS,eAISmC,IAAhC0b,GAAe+E,KACjBrjB,GAAese,GAAgB+E,GAAa,CAC1CjhB,cAAc,EACdkB,MAAO8f,GAAO,YCEdE,GAAmBC,GAAmCC,GCZ1DC,IAFY3jB,GAEY,WACtB,SAASojB,IAAmB,CAG5B,OAFAA,EAAEziB,UAAUqL,YAAc,KAEnB/L,OAAO2jB,eAAe,IAAIR,KAASA,EAAEziB,SAC9C,ICPIiB,GAAS5B,EACT+C,GAAarB,EACbF,GAAWqC,EAEXggB,GAA2B/b,GAE3Bka,GAHYxb,GAGS,YACrBjF,GAAUtB,OACV6jB,GAAkBviB,GAAQZ,UAK9BojB,GAAiBF,GAA2BtiB,GAAQqiB,eAAiB,SAAUta,GAC7E,IAAIU,EAASxI,GAAS8H,GACtB,GAAI1H,GAAOoI,EAAQgY,IAAW,OAAOhY,EAAOgY,IAC5C,IAAIhW,EAAchC,EAAOgC,YACzB,OAAIjJ,GAAWiJ,IAAgBhC,aAAkBgC,EACxCA,EAAYrL,UACZqJ,aAAkBzI,GAAUuiB,GAAkB,IACzD,EFpBIlkB,GAAQI,EACR+C,GAAarB,EACb4C,GAAWT,EAEX+f,GAAiB9b,GACjBoF,GAAgBlF,GAIhBuW,GAHkBlU,GAGS,YAC3B2Z,IAAyB,EAOzB,GAAG/Z,OAGC,SAFNyZ,GAAgB,GAAGzZ,SAIjBwZ,GAAoCG,GAAeA,GAAeF,QACxBzjB,OAAOU,YAAW6iB,GAAoBC,IAHlDO,IAAyB,GAO3D,IAAIC,IAA0B3f,GAASkf,KAAsB5jB,IAAM,WACjE,IAAIS,EAAO,CAAA,EAEX,OAAOmjB,GAAkBjF,IAAU3d,KAAKP,KAAUA,CACpD,IAEI4jB,KAAwBT,GAAoB,IAK3CzgB,GAAWygB,GAAkBjF,MAChCrR,GAAcsW,GAAmBjF,IAAU,WACzC,OAAOjb,IACX,IAGA,IAAA4gB,GAAiB,CACfV,kBAAmBA,GACnBQ,uBAAwBA,IG9CtBR,GAAoBxjB,GAAuCwjB,kBAC3DF,GAAS5hB,GACTkI,GAA2B/F,GAC3BmP,GAAiBxM,GACjB8X,GAAYxW,GAEZqc,GAAa,WAAc,OAAO7gB,MCNlCsX,GAAI5a,GACJY,GAAOc,GAGPqB,GAAa+E,EACbsc,GDGa,SAAUC,EAAqBC,EAAMjN,EAAMkN,GAC1D,IAAIrS,EAAgBoS,EAAO,YAI3B,OAHAD,EAAoB1jB,UAAY2iB,GAAOE,GAAmB,CAAEnM,KAAMzN,KAA2B2a,EAAiBlN,KAC9GrE,GAAeqR,EAAqBnS,GAAe,GACnDoM,GAAUpM,GAAiBiS,GACpBE,CACT,ECRIT,GAAiBvZ,GACjBsI,GAAiBrI,GACjB0I,GAAiB9B,GACjBnH,GAA8BwP,GAC9BrM,GAAgB4H,GAEhBwJ,GAAYtD,GAGZwJ,GAZehe,EAYqBrE,OACpC8I,GAbezE,EAa2BnE,aAC1CmhB,GAJgBiB,GAIkBjB,kBAClCQ,GALgBS,GAKuBT,uBACvCzF,GARkBvJ,GAQS,YAC3B0P,GAAO,OACPC,GAAS,SACTC,GAAU,UAEVT,GAAa,WAAc,OAAO7gB,MAEtCuhB,GAAiB,SAAUC,EAAUR,EAAMD,EAAqBhN,EAAM0N,EAASC,EAAQC,GACrFb,GAA0BC,EAAqBC,EAAMjN,GAErD,IAqBI6N,EAA0BC,EAASC,EArBnCC,EAAqB,SAAUC,GACjC,GAAIA,IAASP,GAAWQ,EAAiB,OAAOA,EAChD,IAAKvB,IAA0BsB,GAAQA,KAAQE,EAAmB,OAAOA,EAAkBF,GAE3F,OAAQA,GACN,KAAKZ,GACL,KAAKC,GACL,KAAKC,GAAS,OAAO,WAAqB,OAAO,IAAIP,EAAoB/gB,KAAMgiB,IAGjF,OAAO,WAAc,OAAO,IAAIjB,EAAoB/gB,KAAM,CAC9D,EAEM4O,EAAgBoS,EAAO,YACvBmB,GAAwB,EACxBD,EAAoBV,EAASnkB,UAC7B+kB,EAAiBF,EAAkBjH,KAClCiH,EAAkB,eAClBT,GAAWS,EAAkBT,GAC9BQ,GAAmBvB,IAA0B0B,GAAkBL,EAAmBN,GAClFY,EAA6B,UAATrB,GAAmBkB,EAAkBI,SAA4BF,EA+BzF,GA3BIC,IACFT,EAA2BtB,GAAe+B,EAAkB/kB,KAAK,IAAIkkB,OACpC7kB,OAAOU,WAAaukB,EAAyB7N,OAC5DuM,GAAesB,KAA8B1B,KACvD7Q,GACFA,GAAeuS,EAA0B1B,IAC/BzgB,GAAWmiB,EAAyB3G,MAC9CrR,GAAcgY,EAA0B3G,GAAU4F,KAItDnR,GAAekS,EAA0BhT,GAAe,IAMxDsS,IAAwBO,IAAYJ,IAAUe,GAAkBA,EAAetjB,OAASuiB,KAC1E1Z,GACdlB,GAA4Byb,EAAmB,OAAQb,KAEvDc,GAAwB,EACxBF,EAAkB,WAAoB,OAAO3kB,GAAK8kB,EAAgBpiB,SAKlEyhB,EAMF,GALAI,EAAU,CACRxE,OAAQ0E,EAAmBV,IAC3B1a,KAAM+a,EAASO,EAAkBF,EAAmBX,IACpDkB,QAASP,EAAmBT,KAE1BK,EAAQ,IAAKG,KAAOD,GAClBnB,IAA0ByB,KAA2BL,KAAOI,KAC9DtY,GAAcsY,EAAmBJ,EAAKD,EAAQC,SAE3CxK,GAAE,CAAE1O,OAAQoY,EAAMxR,OAAO,EAAM9B,OAAQgT,IAA0ByB,GAAyBN,GASnG,OAL4BK,EAAkBjH,MAAcgH,GAC1DrY,GAAcsY,EAAmBjH,GAAUgH,EAAiB,CAAEnjB,KAAM2iB,IAEtEzG,GAAUgG,GAAQiB,EAEXJ,CACT,EClGAU,GAAiB,SAAUriB,EAAOqa,GAChC,MAAO,CAAEra,MAAOA,EAAOqa,KAAMA,EAC/B,ECJI7Q,GAAkBhN,GAClB8lB,GPgBa,SAAUjkB,GACzB2c,GAAe+E,IAAa1hB,IAAO,CACrC,EOjBIyc,GAAYza,GACZ4X,GAAsBjV,GACtBtG,GAAiB4H,EAA+CuB,EAChE0c,GAAiB/d,GACjB6d,GAAyBxb,GAEzBvI,GAAcoP,EAEd8U,GAAiB,iBACjB9J,GAAmBT,GAAoB/R,IACvCyB,GAAmBsQ,GAAoB3Q,UAAUkb,IAYrDC,GAAiBF,GAAelT,MAAO,SAAS,SAAUqT,EAAUnH,GAClE7C,GAAiB5Y,KAAM,CACrB0H,KAAMgb,GACN9Z,OAAQc,GAAgBkZ,GACxBjY,MAAO,EACP8Q,KAAMA,GAIV,IAAG,WACD,IAAIvU,EAAQW,GAAiB7H,MACzB4I,EAAS1B,EAAM0B,OACf+B,EAAQzD,EAAMyD,QAClB,IAAK/B,GAAU+B,GAAS/B,EAAO/G,OAE7B,OADAqF,EAAM0B,YAASpJ,EACR+iB,QAAuB/iB,GAAW,GAE3C,OAAQ0H,EAAMuU,MACZ,IAAK,OAAQ,OAAO8G,GAAuB5X,GAAO,GAClD,IAAK,SAAU,OAAO4X,GAAuB3Z,EAAO+B,IAAQ,GAC5D,OAAO4X,GAAuB,CAAC5X,EAAO/B,EAAO+B,KAAS,EAC1D,GAAG,UAKC0S,GAASrC,GAAU6H,UAAY7H,GAAUzL,MAQ7C,GALAiT,GAAiB,QACjBA,GAAiB,UACjBA,GAAiB,WAGDhkB,IAA+B,WAAhB6e,GAAOve,KAAmB,IACvDlC,GAAeygB,GAAQ,OAAQ,CAAEnd,MAAO,UAC1C,CAAE,MAAO1D,IC5DT,IAAI+M,GAAU7M,GAEV6E,GAAUR,OAEdN,GAAiB,SAAUtC,GACzB,GAA0B,WAAtBoL,GAAQpL,GAAwB,MAAM,IAAIJ,UAAU,6CACxD,OAAOwD,GAAQpD,EACjB,ECPI8F,GAAcvH,EACd4N,GAAsBlM,GACtBqC,GAAWF,GACXvC,GAAyBkF,EAEzB4f,GAAS7e,GAAY,GAAG6e,QACxBC,GAAa9e,GAAY,GAAG8e,YAC5Bjb,GAAc7D,GAAY,GAAG8D,OAE7BiD,GAAe,SAAUgY,GAC3B,OAAO,SAAU9X,EAAO+X,GACtB,IAGIC,EAAOC,EAHP3U,EAAI/N,GAASzC,GAAuBkN,IACpCkY,EAAW9Y,GAAoB2Y,GAC/BI,EAAO7U,EAAE3M,OAEb,OAAIuhB,EAAW,GAAKA,GAAYC,EAAaL,EAAoB,QAAKxjB,GACtE0jB,EAAQH,GAAWvU,EAAG4U,IACP,OAAUF,EAAQ,OAAUE,EAAW,IAAMC,IACtDF,EAASJ,GAAWvU,EAAG4U,EAAW,IAAM,OAAUD,EAAS,MAC3DH,EACEF,GAAOtU,EAAG4U,GACVF,EACFF,EACElb,GAAY0G,EAAG4U,EAAUA,EAAW,GACVD,EAAS,OAAlCD,EAAQ,OAAU,IAA0B,KACzD,CACA,EC1BIJ,GD4Ba,CAGfQ,OAAQtY,IAAa,GAGrB8X,OAAQ9X,IAAa,IClC+B8X,OAClDriB,GAAWrC,GACX+Z,GAAsB5X,GACtBkiB,GAAiBvf,GACjBqf,GAAyB/d,GAEzB+e,GAAkB,kBAClB3K,GAAmBT,GAAoB/R,IACvCyB,GAAmBsQ,GAAoB3Q,UAAU+b,IAIrDd,GAAe1hB,OAAQ,UAAU,SAAU6hB,GACzChK,GAAiB5Y,KAAM,CACrB0H,KAAM6b,GACN1W,OAAQpM,GAASmiB,GACjBjY,MAAO,GAIX,IAAG,WACD,IAGI6Y,EAHAtc,EAAQW,GAAiB7H,MACzB6M,EAAS3F,EAAM2F,OACflC,EAAQzD,EAAMyD,MAElB,OAAIA,GAASkC,EAAOhL,OAAe0gB,QAAuB/iB,GAAW,IACrEgkB,EAAQV,GAAOjW,EAAQlC,GACvBzD,EAAMyD,OAAS6Y,EAAM3hB,OACd0gB,GAAuBiB,GAAO,GACvC,IC7BA,IAAAC,GAAA,CAAAvkB,QAAA,CAAA,GAAAwkB,GAAA,CAAA,EAAIle,GAAgB9I,GAChB8J,GAAuBpI,EACvBkI,GAA2B/F,GCF3BmK,GAAkBhO,GAClBoO,GAAoB1M,GACpBulB,GDEa,SAAUjd,EAAQnI,EAAK2B,GACtC,IAAI0jB,EAAcpe,GAAcjH,GAC5BqlB,KAAeld,EAAQF,GAAqBT,EAAEW,EAAQkd,EAAatd,GAAyB,EAAGpG,IAC9FwG,EAAOkd,GAAe1jB,CAC7B,ECJI2jB,GAAStU,MACT/E,GAAM7K,KAAK6K,ICJXjB,GAAU7M,GACVgN,GAAkBtL,GAClB0lB,GAAuBvjB,GAAsDwF,EAC7EmL,GDGa,SAAUlL,EAAG+d,EAAOC,GAMnC,IALA,IAAIniB,EAASiJ,GAAkB9E,GAC3Bie,EAAIvZ,GAAgBqZ,EAAOliB,GAC3BqiB,EAAMxZ,QAAwBlL,IAARwkB,EAAoBniB,EAASmiB,EAAKniB,GACxDyD,EAASue,GAAOrZ,GAAI0Z,EAAMD,EAAG,IAC7B5Z,EAAI,EACD4Z,EAAIC,EAAKD,IAAK5Z,IAAKsZ,GAAere,EAAQ+E,EAAGrE,EAAEie,IAEtD,OADA3e,EAAOzD,OAASwI,EACT/E,CACT,ECVI6e,GAA+B,iBAAVrkB,QAAsBA,QAAUnD,OAAOoP,oBAC5DpP,OAAOoP,oBAAoBjM,QAAU,GAWzC4jB,GAAA3d,EAAmB,SAA6BlI,GAC9C,OAAOsmB,IAA+B,WAAhB5a,GAAQ1L,GAVX,SAAUA,GAC7B,IACE,OAAOimB,GAAqBjmB,EAC7B,CAAC,MAAOrB,GACP,OAAO0U,GAAWiT,GACnB,CACH,CAKMC,CAAevmB,GACfimB,GAAqBpa,GAAgB7L,GAC3C,ECrBA,IAEAwmB,GAFY3nB,GAEW,WACrB,GAA0B,mBAAf4nB,YAA2B,CACpC,IAAIC,EAAS,IAAID,YAAY,GAEzB3nB,OAAO6nB,aAAaD,IAAS5nB,OAAOC,eAAe2nB,EAAQ,IAAK,CAAErkB,MAAO,GAC9E,CACH,ICTI5D,GAAQI,EACRsE,GAAW5C,EACXmL,GAAUhJ,GACVkkB,GAA8BvhB,GAG9BwhB,GAAgB/nB,OAAO6nB,aAK3BG,GAJ0BroB,IAAM,WAAcooB,GAAc,EAAG,KAItBD,GAA+B,SAAsB5mB,GAC5F,QAAKmD,GAASnD,OACV4mB,IAA+C,gBAAhBlb,GAAQ1L,OACpC6mB,IAAgBA,GAAc7mB,IACvC,EAAI6mB,GCbJE,IAFYloB,GAEY,WAEtB,OAAOC,OAAO6nB,aAAa7nB,OAAOkoB,kBAAkB,CAAA,GACtD,ICLIvN,GAAI5a,GACJuH,GAAc7F,EACdyI,GAAatG,GACbS,GAAWkC,EACX5E,GAASkG,EACT5H,GAAiB8H,EAA+CqB,EAChEkG,GAA4BlF,GAC5B+d,GAAoC9d,GACpCwd,GAAe5W,GAEfmX,GAAWvT,GAEXwT,IAAW,EACXC,GAJMhP,GAIS,QACf/R,GAAK,EAELghB,GAAc,SAAUrnB,GAC1BjB,GAAeiB,EAAIonB,GAAU,CAAE/kB,MAAO,CACpCilB,SAAU,IAAMjhB,KAChBkhB,SAAU,CAAE,IAEhB,EA4DIC,GAAOC,GAAApmB,QAAiB,CAC1BqmB,OA3BW,WACXF,GAAKE,OAAS,aACdP,IAAW,EACX,IAAIjZ,EAAsBE,GAA0BlG,EAChDyf,EAASvhB,GAAY,GAAGuhB,QACxBzoB,EAAO,CAAA,EACXA,EAAKkoB,IAAY,EAGblZ,EAAoBhP,GAAM8E,SAC5BoK,GAA0BlG,EAAI,SAAUlI,GAEtC,IADA,IAAIyH,EAASyG,EAAoBlO,GACxB6N,EAAI,EAAG7J,EAASyD,EAAOzD,OAAQ6J,EAAI7J,EAAQ6J,IAClD,GAAIpG,EAAOoG,KAAOuZ,GAAU,CAC1BO,EAAOlgB,EAAQoG,EAAG,GAClB,KACD,CACD,OAAOpG,CACf,EAEIgS,GAAE,CAAE1O,OAAQ,SAAU4E,MAAM,EAAME,QAAQ,GAAQ,CAChD3B,oBAAqB+Y,GAAkC/e,IAG7D,EAIE0f,QA5DY,SAAU5nB,EAAImiB,GAE1B,IAAKhf,GAASnD,GAAK,MAAoB,iBAANA,EAAiBA,GAAmB,iBAANA,EAAiB,IAAM,KAAOA,EAC7F,IAAKS,GAAOT,EAAIonB,IAAW,CAEzB,IAAKT,GAAa3mB,GAAK,MAAO,IAE9B,IAAKmiB,EAAQ,MAAO,IAEpBkF,GAAYrnB,EAEb,CAAC,OAAOA,EAAGonB,IAAUE,QACxB,EAiDEO,YA/CgB,SAAU7nB,EAAImiB,GAC9B,IAAK1hB,GAAOT,EAAIonB,IAAW,CAEzB,IAAKT,GAAa3mB,GAAK,OAAO,EAE9B,IAAKmiB,EAAQ,OAAO,EAEpBkF,GAAYrnB,EAEb,CAAC,OAAOA,EAAGonB,IAAUG,QACxB,EAsCEO,SAnCa,SAAU9nB,GAEvB,OADIknB,IAAYC,IAAYR,GAAa3mB,KAAQS,GAAOT,EAAIonB,KAAWC,GAAYrnB,GAC5EA,CACT,GAmCAgJ,GAAWoe,KAAY,oBCxFnBxlB,GAAa/C,EACbsE,GAAW5C,EACXiR,GAAiB9O,GCFjB+W,GAAI5a,GACJkD,GAASxB,EACT6F,GAAc1D,EACd+L,GAAWpJ,GACX0G,GAAgBpF,GAChBohB,GAAyBlhB,GACzBqX,GAAUhV,GACV8I,GAAa7I,GACbvH,GAAamO,EACbhQ,GAAoBqY,EACpBjV,GAAWwQ,EACXlV,GAAQoV,EACRqL,GAA8BrF,GAC9BhI,GAAiByR,GACjB0E,GDTa,SAAU3a,EAAO4a,EAAOC,GACvC,IAAIC,EAAWC,EAUf,OAPE5W,IAEA5P,GAAWumB,EAAYF,EAAMpd,cAC7Bsd,IAAcD,GACd/kB,GAASilB,EAAqBD,EAAU3oB,YACxC4oB,IAAuBF,EAAQ1oB,WAC/BgS,GAAenE,EAAO+a,GACjB/a,CACT,EEjBItB,GAAgBlN,GCAhB6M,GAAU7M,GCAVwpB,GDKa3W,MAAM2W,SAAW,SAAiB/nB,GACjD,MAA6B,UAAtBoL,GAAQpL,EACjB,ECNIuS,GAAgBtS,GAChB4C,GAAWT,EAGXqP,GAFkB1M,GAEQ,WAC1B2gB,GAAStU,MCNT4W,GDUa,SAAUC,GACzB,IAAItP,EASF,OAREoP,GAAQE,KACVtP,EAAIsP,EAAc1d,aAEdgI,GAAcoG,KAAOA,IAAM+M,IAAUqC,GAAQpP,EAAEzZ,aAC1C2D,GAAS8V,IAEN,QADVA,EAAIA,EAAElH,QAFwDkH,OAAItX,SAKvDA,IAANsX,EAAkB+M,GAAS/M,CACtC,EErBI9Z,GAAON,GAEP+M,GAAgBlJ,GAChBrC,GAAWgF,EACX4H,GAAoBtG,GACpB6hB,GDDa,SAAUD,EAAevkB,GACxC,OAAO,IAAKskB,GAAwBC,GAA7B,CAAwD,IAAXvkB,EAAe,EAAIA,EACzE,ECCI+B,GANcxF,EAMK,GAAGwF,MAGtBoH,GAAe,SAAUvD,GAC3B,IAAI6e,EAAkB,IAAT7e,EACT8e,EAAqB,IAAT9e,EACZ+e,EAAmB,IAAT/e,EACVgf,EAAoB,IAAThf,EACXif,EAAyB,IAATjf,EAChBkf,EAA4B,IAATlf,EACnBmf,EAAoB,IAATnf,GAAcif,EAC7B,OAAO,SAAUxb,EAAO2b,EAAY7V,EAAM8V,GASxC,IARA,IAOI5mB,EAAOoF,EAPPU,EAAI9H,GAASgN,GACbnL,EAAO0J,GAAczD,GACrBnE,EAASiJ,GAAkB/K,GAC3BgnB,EAAgB/pB,GAAK6pB,EAAY7V,GACjCrG,EAAQ,EACRqV,EAAS8G,GAAkBT,GAC3Bzd,EAAS0d,EAAStG,EAAO9U,EAAOrJ,GAAU0kB,GAAaI,EAAmB3G,EAAO9U,EAAO,QAAK1L,EAE3FqC,EAAS8I,EAAOA,IAAS,IAAIic,GAAYjc,KAAS5K,KAEtDuF,EAASyhB,EADT7mB,EAAQH,EAAK4K,GACiBA,EAAO3E,GACjCyB,GACF,GAAI6e,EAAQ1d,EAAO+B,GAASrF,OACvB,GAAIA,EAAQ,OAAQmC,GACvB,KAAK,EAAG,OAAO,EACf,KAAK,EAAG,OAAOvH,EACf,KAAK,EAAG,OAAOyK,EACf,KAAK,EAAG/G,GAAKgF,EAAQ1I,QAChB,OAAQuH,GACb,KAAK,EAAG,OAAO,EACf,KAAK,EAAG7D,GAAKgF,EAAQ1I,GAI3B,OAAOwmB,GAAiB,EAAIF,GAAWC,EAAWA,EAAW7d,CACjE,CACA,EAEAoe,GAAiB,CAGf5Y,QAASpD,GAAa,GAGtBic,IAAKjc,GAAa,GAGlBkc,OAAQlc,GAAa,GAGrBmc,KAAMnc,GAAa,GAGnBoc,MAAOpc,GAAa,GAGpBqc,KAAMrc,GAAa,GAGnBsc,UAAWtc,GAAa,GAGxBuc,aAAcvc,GAAa,ICvEzB/G,GAAcvH,EACd8qB,GLCa,SAAU5e,EAAQ+W,EAAKrX,GACtC,IAAK,IAAI/J,KAAOohB,EAAK/V,GAAchB,EAAQrK,EAAKohB,EAAIphB,GAAM+J,GAC1D,OAAOM,CACT,EKHI8c,GAAcnlB,GAA0CmlB,YACxD7V,GAAa3M,GACb1B,GAAWgD,GACX5G,GAAoB8G,EACpB1D,GAAW+F,EACXgV,GAAU/U,GAEV1I,GAAS2X,EAGT2C,GAFsBpH,GAEiBpL,IACvCqhB,GAHsBjW,GAGuBhK,UAC7C6f,GANuBzZ,GAMKyZ,KAC5BC,GAPuB1Z,GAOU0Z,UACjC9B,GAASvhB,GAAY,GAAGuhB,QACxBthB,GAAK,EAGLwjB,GAAsB,SAAUxgB,GAClC,OAAOA,EAAMygB,SAAWzgB,EAAMygB,OAAS,IAAIC,GAC7C,EAEIA,GAAsB,WACxB5nB,KAAKsiB,QAAU,EACjB,EAEIuF,GAAqB,SAAUvnB,EAAO/B,GACxC,OAAO8oB,GAAK/mB,EAAMgiB,SAAS,SAAUzkB,GACnC,OAAOA,EAAG,KAAOU,CACrB,GACA,EAEAqpB,GAAoBvqB,UAAY,CAC9BR,IAAK,SAAU0B,GACb,IAAIuV,EAAQ+T,GAAmB7nB,KAAMzB,GACrC,GAAIuV,EAAO,OAAOA,EAAM,EACzB,EACDzN,IAAK,SAAU9H,GACb,QAASspB,GAAmB7nB,KAAMzB,EACnC,EACD6H,IAAK,SAAU7H,EAAK2B,GAClB,IAAI4T,EAAQ+T,GAAmB7nB,KAAMzB,GACjCuV,EAAOA,EAAM,GAAK5T,EACjBF,KAAKsiB,QAAQ1e,KAAK,CAACrF,EAAK2B,GAC9B,EACD4nB,OAAU,SAAUvpB,GAClB,IAAIoM,EAAQ2c,GAAUtnB,KAAKsiB,SAAS,SAAUzkB,GAC5C,OAAOA,EAAG,KAAOU,CACvB,IAEI,OADKoM,GAAO6a,GAAOxlB,KAAKsiB,QAAS3X,EAAO,MAC9BA,CACX,GAGH,IAAAod,GAAiB,CACfC,eAAgB,SAAUvN,EAASjD,EAAkB8O,EAAQ2B,GAC3D,IAAIxQ,EAAcgD,GAAQ,SAAUzJ,EAAMgL,GACxCnM,GAAWmB,EAAMlB,GACjB8I,GAAiB5H,EAAM,CACrBtJ,KAAM8P,EACNtT,GAAIA,KACJyjB,YAAQnoB,IAEL5B,GAAkBoe,IAAWD,GAAQC,EAAUhL,EAAKiX,GAAQ,CAAEjX,KAAMA,EAAMoL,WAAYkK,GACjG,IAEQxW,EAAY2H,EAAYpa,UAExBwK,EAAmB4f,GAAuBjQ,GAE1C0Q,EAAS,SAAUlX,EAAMzS,EAAK2B,GAChC,IAAIgH,EAAQW,EAAiBmJ,GACzBvE,EAAOiZ,GAAYlkB,GAASjD,IAAM,GAGtC,OAFa,IAATkO,EAAeib,GAAoBxgB,GAAOd,IAAI7H,EAAK2B,GAClDuM,EAAKvF,EAAMhD,IAAMhE,EACf8Q,CACb,EAiDI,OA/CAwW,GAAe1X,EAAW,CAIxBgY,OAAU,SAAUvpB,GAClB,IAAI2I,EAAQW,EAAiB7H,MAC7B,IAAKgB,GAASzC,GAAM,OAAO,EAC3B,IAAIkO,EAAOiZ,GAAYnnB,GACvB,OAAa,IAATkO,EAAsBib,GAAoBxgB,GAAe,OAAE3I,GACxDkO,GAAQnO,GAAOmO,EAAMvF,EAAMhD,YAAcuI,EAAKvF,EAAMhD,GAC5D,EAIDmC,IAAK,SAAa9H,GAChB,IAAI2I,EAAQW,EAAiB7H,MAC7B,IAAKgB,GAASzC,GAAM,OAAO,EAC3B,IAAIkO,EAAOiZ,GAAYnnB,GACvB,OAAa,IAATkO,EAAsBib,GAAoBxgB,GAAOb,IAAI9H,GAClDkO,GAAQnO,GAAOmO,EAAMvF,EAAMhD,GACnC,IAGHsjB,GAAe1X,EAAWwW,EAAS,CAGjCzpB,IAAK,SAAa0B,GAChB,IAAI2I,EAAQW,EAAiB7H,MAC7B,GAAIgB,GAASzC,GAAM,CACjB,IAAIkO,EAAOiZ,GAAYnnB,GACvB,OAAa,IAATkO,EAAsBib,GAAoBxgB,GAAOrK,IAAI0B,GAClDkO,EAAOA,EAAKvF,EAAMhD,SAAM1E,CAChC,CACF,EAGD4G,IAAK,SAAa7H,EAAK2B,GACrB,OAAOgoB,EAAOloB,KAAMzB,EAAK2B,EAC1B,GACC,CAGF0T,IAAK,SAAa1T,GAChB,OAAOgoB,EAAOloB,KAAME,GAAO,EAC5B,IAGIuX,CACR,INhHc,SAAUD,EAAkBiD,EAAS0N,GACpD,IAAI7B,GAA8C,IAArC9O,EAAiBjM,QAAQ,OAClC6c,GAAgD,IAAtC5Q,EAAiBjM,QAAQ,QACnC0c,EAAQ3B,EAAS,MAAQ,MACzB+B,EAAoBzoB,GAAO4X,GAC3B8Q,EAAkBD,GAAqBA,EAAkBhrB,UACzDoa,EAAc4Q,EACdE,EAAW,CAAA,EAEXC,EAAY,SAAU1G,GACxB,IAAI2G,EAAwBxkB,GAAYqkB,EAAgBxG,IACxDlY,GAAc0e,EAAiBxG,EACrB,QAARA,EAAgB,SAAa5hB,GAE3B,OADAuoB,EAAsBzoB,KAAgB,IAAVE,EAAc,EAAIA,GACvCF,IACf,EAAkB,WAAR8hB,EAAmB,SAAUvjB,GAC/B,QAAO6pB,IAAYpnB,GAASzC,KAAekqB,EAAsBzoB,KAAc,IAARzB,EAAY,EAAIA,EACxF,EAAW,QAARujB,EAAgB,SAAavjB,GAC/B,OAAO6pB,IAAYpnB,GAASzC,QAAOiB,EAAYipB,EAAsBzoB,KAAc,IAARzB,EAAY,EAAIA,EAC5F,EAAW,QAARujB,EAAgB,SAAavjB,GAC/B,QAAO6pB,IAAYpnB,GAASzC,KAAekqB,EAAsBzoB,KAAc,IAARzB,EAAY,EAAIA,EAC/F,EAAU,SAAaA,EAAK2B,GAEpB,OADAuoB,EAAsBzoB,KAAc,IAARzB,EAAY,EAAIA,EAAK2B,GAC1CF,IACR,EAEP,EASE,GAPcsM,GACZkL,GACC/X,GAAW4oB,MAAwBD,GAAWE,EAAgBla,UAAY9R,IAAM,YAC/E,IAAI+rB,GAAoB/F,UAAUvO,MACxC,MAKI0D,EAAc0Q,EAAOH,eAAevN,EAASjD,EAAkB8O,EAAQ2B,GACvErC,GAAuBL,cAClB,GAAIjZ,GAASkL,GAAkB,GAAO,CAC3C,IAAIkR,EAAW,IAAIjR,EAEfkR,EAAiBD,EAAST,GAAOG,EAAU,CAAE,GAAI,EAAG,KAAOM,EAE3DE,EAAuBtsB,IAAM,WAAcosB,EAASriB,IAAI,EAAG,IAG3DwiB,EAAmB9L,IAA4B,SAAUf,GAAY,IAAIqM,EAAkBrM,EAAU,IAErG8M,GAAcV,GAAW9rB,IAAM,WAIjC,IAFA,IAAIysB,EAAY,IAAIV,EAChB1d,EAAQ,EACLA,KAASoe,EAAUd,GAAOtd,EAAOA,GACxC,OAAQoe,EAAU1iB,KAAK,EAC7B,IAESwiB,KACHpR,EAAcgD,GAAQ,SAAUqL,EAAO9J,GACrCnM,GAAWiW,EAAOwC,GAClB,IAAItX,EAAO6U,GAAkB,IAAIwC,EAAqBvC,EAAOrO,GAE7D,OADK7Z,GAAkBoe,IAAWD,GAAQC,EAAUhL,EAAKiX,GAAQ,CAAEjX,KAAMA,EAAMoL,WAAYkK,IACpFtV,CACf,KACkB3T,UAAYirB,EACxBA,EAAgB5f,YAAc+O,IAG5BmR,GAAwBE,KAC1BN,EAAU,UACVA,EAAU,OACVlC,GAAUkC,EAAU,SAGlBM,GAAcH,IAAgBH,EAAUP,GAGxCG,GAAWE,EAAgB1W,cAAc0W,EAAgB1W,KAC9D,CAED2W,EAAS/Q,GAAoBC,EAC7BH,GAAE,CAAE1X,QAAQ,EAAM8I,aAAa,EAAMgF,OAAQ+J,IAAgB4Q,GAAqBE,GAElF7Y,GAAe+H,EAAaD,GAEvB4Q,GAASD,EAAOa,UAAUvR,EAAaD,EAAkB8O,EAGhE,EOnGA2C,CAAW,WAAW,SAAUC,GAC9B,OAAO,WAAqB,OAAOA,EAAKlpB,KAAMrC,UAAUkE,OAASlE,UAAU,QAAK6B,EAAW,CAC7F,GANqBpB,ICCrB,IAAA+qB,GAAiB,CACfC,YAAa,EACbC,oBAAqB,EACrBC,aAAc,EACdC,eAAgB,EAChBC,YAAa,EACbC,cAAe,EACfC,aAAc,EACdC,qBAAsB,EACtBC,SAAU,EACVC,kBAAmB,EACnBC,eAAgB,EAChBC,gBAAiB,EACjBC,kBAAmB,EACnBC,UAAW,EACXC,cAAe,EACfC,aAAc,EACdC,SAAU,EACVC,iBAAkB,EAClBC,OAAQ,EACRC,YAAa,EACbC,cAAe,EACfC,cAAe,EACfC,eAAgB,EAChBC,aAAc,EACdC,cAAe,EACfC,iBAAkB,EAClBC,iBAAkB,EAClBC,eAAgB,EAChBC,iBAAkB,EAClBC,cAAe,EACfC,UAAW,GC9BTC,GAFwBzuB,GAEU,QAAQyuB,UAC1CC,GAAwBD,IAAaA,GAAUziB,aAAeyiB,GAAUziB,YAAYrL,UAExFguB,GAAiBD,KAA0BzuB,OAAOU,eAAYmC,EAAY4rB,GCNtExrB,GAASlD,EACT4uB,GAAeltB,GACfgtB,GAAwB7qB,GACxBgrB,GAAuBroB,GACvBuD,GAA8BjC,GAC9BkL,GAAiBhL,GAGjBuW,GAFkBlU,GAES,YAC3BykB,GAAcD,GAAqBlO,OAEnCoO,GAAkB,SAAUC,EAAqBC,GACnD,GAAID,EAAqB,CAEvB,GAAIA,EAAoBzQ,MAAcuQ,GAAa,IACjD/kB,GAA4BilB,EAAqBzQ,GAAUuQ,GAC5D,CAAC,MAAOhvB,GACPkvB,EAAoBzQ,IAAYuQ,EACjC,CAED,GADA9b,GAAegc,EAAqBC,GAAiB,GACjDL,GAAaK,GAAkB,IAAK,IAAI5N,KAAewN,GAEzD,GAAIG,EAAoB3N,KAAiBwN,GAAqBxN,GAAc,IAC1EtX,GAA4BilB,EAAqB3N,EAAawN,GAAqBxN,GACpF,CAAC,MAAOvhB,GACPkvB,EAAoB3N,GAAewN,GAAqBxN,EACzD,CAEJ,CACH,EAEA,IAAK,IAAI4N,MAAmBL,GAC1BG,GAAgB7rB,GAAO+rB,KAAoB/rB,GAAO+rB,IAAiBtuB,UAAWsuB,IAGhFF,GAAgBL,GAAuB,gBCnCvC,IAAIQ,GAAWlvB,GAAwC0R,QCAnDxO,GAASlD,EACT4uB,GAAeltB,GACfgtB,GAAwB7qB,GACxB6N,GDFsBhQ,GAEc,WAOpC,GAAGgQ,QAH2B,SAAiByY,GACjD,OAAO+E,GAAS5rB,KAAM6mB,EAAYlpB,UAAUkE,OAAS,EAAIlE,UAAU,QAAK6B,EAE1E,ECNIiH,GAA8BjC,GAE9BinB,GAAkB,SAAUC,GAE9B,GAAIA,GAAuBA,EAAoBtd,UAAYA,GAAS,IAClE3H,GAA4BilB,EAAqB,UAAWtd,GAC7D,CAAC,MAAO5R,GACPkvB,EAAoBtd,QAAUA,EAC/B,CACH,EAEA,IAAK,IAAIud,MAAmBL,GACtBA,GAAaK,KACfF,GAAgB7rB,GAAO+rB,KAAoB/rB,GAAO+rB,IAAiBtuB,WAIvEouB,GAAgBL,ICrBhB,ICDYS,GAMAC,2BDJR5tB,GAAWE,EACX2tB,GAAaxrB,GEiRV,SAASyrB,GAAuBC,EAAU/kB,EAAOuU,EAAM1V,GAC1D,GAAa,MAAT0V,IAAiB1V,EAAG,MAAM,IAAIhI,UAAU,iDAC5C,GAAqB,mBAAVmJ,EAAuB+kB,IAAa/kB,IAAUnB,GAAKmB,EAAMb,IAAI4lB,GAAW,MAAM,IAAIluB,UAAU,4EACvG,MAAgB,MAAT0d,EAAe1V,EAAa,MAAT0V,EAAe1V,EAAEzI,KAAK2uB,GAAYlmB,EAAIA,EAAE7F,MAAQgH,EAAMrK,IAAIovB,EACxF,CCjRM,SAAUC,GAAW9I,GACzB,MAAoB,QAAbA,GAAmC,WAAbA,CAC/B,CAEM,SAAU+I,GAAkBC,GAChC,OAAOA,EAAQN,GAASO,MAAQD,EAAQN,GAASQ,MACnD,CAEM,SAAUC,GAAgBH,GAC9B,OAAOA,EAAQN,GAASU,KAAOJ,EAAQN,GAASW,OAClD,CHhBQ/vB,GASN,CAAEkM,OAAQ,SAAU4E,MAAM,EAAME,OANtBxK,GAEoB,WAAc6oB,GAAW,EAAG,KAIK,CAC/DplB,KAAM,SAAc9I,GAClB,OAAOkuB,GAAW7tB,GAASL,GAC5B,ICbH,SAAYguB,GACVA,EAAAA,EAAA,YAAA,GAAA,cACAA,EAAAA,EAAA,gBAAA,GAAA,kBACAA,EAAAA,EAAA,eAAA,GAAA,gBACD,CAJD,CAAYA,KAAAA,GAIX,CAAA,IAED,SAAYC,GACVA,EAAAA,EAAA,IAAA,GAAA,MACAA,EAAAA,EAAA,MAAA,GAAA,QACAA,EAAAA,EAAA,OAAA,GAAA,SACAA,EAAAA,EAAA,KAAA,GAAA,MACD,CALD,CAAYA,KAAAA,GAKX,CAAA,IGeD,IAAMY,GAAmB,4BAEnBC,GAAuC,CAC3CC,SAAS,EAETC,WAAY,CACVC,MAAO,EACPC,OAAQ,GAGV3J,SAAU,OAEV4J,KAAM,WAAA,MAAM,EAAE,EAEdZ,QAAS,CAAC,EAAG,EAAG,EAAG,IAGAa,GAAa,WAahC,SAAAA,EAAYC,wGAAoBC,MAAAF,gBAZhCjtB,KAAIlB,KAAG,gBAaL,IAAMsuB,EAAsC,QAA1BC,EAAiB,QAAjBC,EAAAJ,aAAA,EAAAA,EAAU5kB,eAAO,IAAAglB,OAAA,EAAAA,EAAEhlB,eAAO,IAAA+kB,OAAA,EAAAA,EAAED,UAE9CptB,KAAKktB,SAAWA,EAChBltB,KAAKutB,KAAO,KACZvtB,KAAKwtB,OAAQ,EACbxtB,KAAKsI,QAAUqkB,GACf3sB,KAAKytB,gBAAkB,CACrBC,OAAQN,aAAA,EAAAA,EAAWM,OACnBZ,MAAOM,aAAA,EAAAA,EAAWN,MAClBC,OAAQK,aAAA,EAAAA,EAAWL,OACnBY,OAAQP,aAAA,EAAAA,EAAWO,OACnBC,UAAW,QAEf,WA+DC,SA/DAX,KAAA,CAAA,CAAA1uB,IAAA,QAAA2B,MAED,SAAM2tB,GACJ7tB,KAAKsI,QAAO3L,OAAAmR,OAAAnR,OAAAmR,OAAA,GAAQ6e,IAAmBkB,EACzC,GAAC,CAAAtvB,IAAA,QAAA2B,MAED,WAGE,IAFoBF,KAAKsI,QAAjBskB,QAGN,OAAO5sB,KAAK8tB,UAGd9tB,KAAKwtB,OAAQ,EAEb,IAAMO,EAAe/tB,KAAKktB,SAASc,gBAAgBT,KAanD,OAXKvtB,KAAKutB,OACRvtB,KAAKutB,KAAOQ,EACTE,OAAO,OACPC,KAAK,QAASxB,GAAiB3kB,MAAM,IACrCmmB,KAAK,WAAYluB,KAAKsI,QAAQ/J,KAC9B2vB,KAAK,IAAK,GACVA,KAAK,IAAK,IAGfluB,KAAKmuB,QAEEtZ,QAAQQ,SACjB,GAAC,CAAA9W,IAAA,UAAA2B,MAED,WAME,OALkB,OAAdF,KAAKutB,OACPvtB,KAAKutB,KAAKa,SACVpuB,KAAKutB,KAAO,MAGP1Y,QAAQQ,SACjB,GAAC,CAAA9W,IAAA,QAAA2B,MAED,WAAK,IAAAmuB,EAAAruB,KAsBH,OArBAgsB,GAAAhsB,KAAIsuB,GAAA,IAAAC,IAAJjxB,KAAA0C,MACAgsB,GAAAhsB,KAAIsuB,GAAA,IAAAE,IAAJlxB,KAAA0C,MAEAA,KAAKutB,KACFkB,UAAU,KACVhiB,KAAKzM,KAAKsI,QAAQ0kB,MAClB/kB,MAAK,SAACmN,GAAU,OAAKA,EACnB6Y,OAAO,KACP3wB,MAAK,SAACoxB,GAAc,OAAKA,EACvBT,OAAO,QACPC,KAAK,QAAO,GAAAriB,OAAK6gB,GAAiB3kB,MAAM,GAAE,QAC1CmmB,KAAK,QAAS,qBACd5wB,MAAK,SAACqxB,GAAM,OAAK3C,GAAAqC,EAAIC,GAAA,IAAAM,SAAJP,EAAkBM,KAAG,IACxCrxB,MAAK,SAACoxB,GAAc,OAAKA,EACvBT,OAAO,QACPC,KAAK,WAAOriB,OAAK6gB,GAAiB3kB,MAAM,GAAS,UACjDmmB,KAAK,oBAAqB,WAC1BA,KAAK,cAAe,UACpBA,KAAK,QAAS,uCACd5wB,MAAK,SAACqxB,GAAM,OAAK3C,GAAAqC,EAAiBC,GAAA,IAAAO,IAAAvxB,KAAjB+wB,EAAkBM,YAEnC9Z,QAAQQ,SACjB,oFAAC4X,CAAA,CA1F+B,2CA6F9BtwB,OAAOgK,KAAK3G,KAAKytB,iBAAiBrf,SAAQ,SAAC7P,QACiB,IAA/CuwB,EAAKxmB,QAAQ/J,KAEtBuwB,EAAKrB,gBAAgBlvB,GAAOuwB,EAAKxmB,QAAQ/J,GAE7C,GACF,EAACiwB,GAAA,WAMC,IAAAO,EAAkC/uB,KAAKytB,gBAA/BX,EAAKiC,EAALjC,MAAOC,EAAMgC,EAANhC,OAAQY,EAAMoB,EAANpB,OACvBqB,EAAoChvB,KAAKsI,QAAjC0kB,EAAIgC,EAAJhC,KAAMZ,EAAO4C,EAAP5C,QAAShJ,EAAQ4L,EAAR5L,SACjB6L,EAAcjC,IAAOnrB,OAE3B7B,KAAKsI,QAAQukB,WAAa,CACxBC,MAAOA,EAAQX,GAAkBC,GACjCW,OAAQA,EAASR,GAAgBH,IAG/BF,GAAW9I,GACbpjB,KAAKsI,QAAQukB,WAAWC,QAAUA,EAAQa,IAAWsB,EAAc,GAEnEjvB,KAAKsI,QAAQukB,WAAWE,SAAWA,EAASY,IAAWsB,EAAc,EAEzE,cAEaP,GAAc,IAAAQ,EAAAlvB,KACzBmvB,EAAkCnvB,KAAKytB,gBAA/BX,EAAKqC,EAALrC,MAAOC,EAAMoC,EAANpC,OAAQW,EAAMyB,EAANzB,OAEvBgB,EACGR,KAAK,QAASpB,GACdoB,KAAK,SAAUnB,GACfmB,KAAK,KAAMR,GAAUA,EAAS,EAAIA,EAAS,MAC3CQ,KAAK,KAAMR,GAAUA,EAAS,EAAIA,EAAS,MAC3CQ,KAAK,KAAK,SAACkB,EAAY1jB,GAAS,OAAKsgB,GAAAkD,EAAUZ,GAAA,IAAAe,IAAA/xB,KAAV4xB,EAAWxjB,EAAG,IACnDwiB,KAAK,KAAK,SAACkB,EAAY1jB,GAAS,OAAKsgB,GAAAkD,aAAA5xB,KAAA4xB,EAAWxjB,KACrD,cAEagjB,GAAc,IAAAY,EAAAtvB,KACzBuvB,EAA8BvvB,KAAKytB,gBAA3BV,EAAMwC,EAANxC,OAAQa,EAAS2B,EAAT3B,UAEhBc,EACGR,KAAK,cAAeN,GACpBM,KACC,KACA,SAACkB,EAAY1jB,GAAS,OAAKsgB,GAAAsD,aAAAhyB,KAAAgyB,GAAyBtD,GAAAsD,EAAUhB,GAAA,IAAAe,IAAA/xB,KAAVgyB,EAAW5jB,EAChE,IACAwiB,KAAK,KAAK,SAACkB,EAAY1jB,GAAS,OAAKsgB,GAAAsD,EAAUhB,GAAA,IAAAkB,IAAAlyB,KAAVgyB,EAAW5jB,GAAKqhB,EAAU,CAAC,IAChEC,MAAK,SAACvgB,GAAY,OAAKA,IAC5B,EAACgjB,GAAA,WAGC,IAAAC,EAA6B1vB,KAAKytB,gBAA1BX,EAAK4C,EAAL5C,MAER,OAFwB4C,EAAT9B,WAGb,IAAK,QAML,QACE,OAAO,EALT,IAAK,SACH,OAAOd,EAAQ,EACjB,IAAK,MACH,OAAOA,EAIb,cAEMniB,GACJ,IAAAglB,EAA8B3vB,KAAKsI,QAA3B8a,EAAQuM,EAARvM,SAAUgJ,EAAOuD,EAAPvD,QAClBwD,EAA0B5vB,KAAKytB,gBAAvBX,EAAK8C,EAAL9C,MAAOa,EAAMiC,EAANjC,OAEf,OD7ME,SAAuBvK,GAC3B,MAAoB,SAAbA,GAAoC,UAAbA,CAChC,CC2MQyM,CAAazM,GACRgJ,EAAQN,GAASO,MAGnBD,EAAQN,GAASO,OAASS,EAAQa,GAAUhjB,CACrD,cAEMA,GACJ,IAAAmlB,EAA8B9vB,KAAKsI,QAA3B8a,EAAQ0M,EAAR1M,SAAUgJ,EAAO0D,EAAP1D,QAClB2D,EAA2B/vB,KAAKytB,gBAAxBV,EAAMgD,EAANhD,OAAQY,EAAMoC,EAANpC,OAEhB,OAAIzB,GAAW9I,GACNgJ,EAAQN,GAASU,KAGnBJ,EAAQN,GAASU,MAAQO,EAASY,GAAUhjB,CACrD,SAACsiB","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,156]} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.js b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.js new file mode 100644 index 0000000..214d137 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.js @@ -0,0 +1 @@ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e():"function"==typeof define&&define.amd?define(e):(t="undefined"!=typeof globalThis?globalThis:t||self).CalendarLabel=e()}(this,(function(){"use strict";function t(t,e){for(var n=0;n0&&W[0]<4?1:+(W[0]+W[1])),!z&&bt&&(!(W=bt.match(/Edge\/(\d+)/))||W[1]>=74)&&(W=bt.match(/Chrome\/(\d+)/))&&(z=+W[1]);var jt=z,Tt=jt,Et=n,Pt=I.String,xt=!!Object.getOwnPropertySymbols&&!Et((function(){var t=Symbol("symbol detection");return!Pt(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&Tt&&Tt<41})),At=xt&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,Lt=dt,Rt=R,Ct=vt,It=Object,kt=At?function(t){return"symbol"==typeof t}:function(t){var e=Lt("Symbol");return Rt(e)&&Ct(e.prototype,It(t))},_t=String,Nt=function(t){try{return _t(t)}catch(t){return"Object"}},Dt=R,Ft=Nt,Mt=TypeError,Gt=function(t){if(Dt(t))return t;throw new Mt(Ft(t)+" is not a function")},Bt=Gt,Ut=s,Wt=function(t,e){var n=t[e];return Ut(n)?void 0:Bt(n)},zt=lt,Ht=R,Vt=J,Kt=TypeError,qt={exports:{}},Xt=M;(qt.exports=function(t,e){return Xt[t]||(Xt[t]=void 0!==e?e:{})})("versions",[]).push({version:"3.34.0",mode:"global",copyright:"© 2014-2023 Denis Pushkarev (zloirock.ru)",license:"https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE",source:"https://github.com/zloirock/core-js"});var Yt=qt.exports,Jt=f,$t=0,Qt=Math.random(),Zt=Jt(1..toString),te=function(t){return"Symbol("+(void 0===t?"":t)+")_"+Zt(++$t+Qt,36)},ee=Yt,ne=m,re=te,oe=xt,ie=At,ue=I.Symbol,ce=ee("wks"),ae=ie?ue.for||ue:ue&&ue.withoutSetter||re,fe=function(t){return ne(ce,t)||(ce[t]=oe&&ne(ue,t)?ue[t]:ae("Symbol."+t)),ce[t]},se=lt,le=J,pe=kt,he=Wt,de=function(t,e){var n,r;if("string"===e&&Ht(n=t.toString)&&!Vt(r=zt(n,t)))return r;if(Ht(n=t.valueOf)&&!Vt(r=zt(n,t)))return r;if("string"!==e&&Ht(n=t.toString)&&!Vt(r=zt(n,t)))return r;throw new Kt("Can't convert object to primitive value")},ve=TypeError,ye=fe("toPrimitive"),ge=function(t,e){if(!le(t)||pe(t))return t;var n,r=he(t,ye);if(r){if(void 0===e&&(e="default"),n=se(r,t,e),!le(n)||pe(n))return n;throw new ve("Can't convert object to primitive value")}return void 0===e&&(e="number"),de(t,e)},be=kt,me=function(t){var e=ge(t,"string");return be(e)?e:e+""},we=r,Oe=rt,Se=ot,je=at,Te=me,Ee=TypeError,Pe=Object.defineProperty,xe=Object.getOwnPropertyDescriptor,Ae="enumerable",Le="configurable",Re="writable";$.f=we?Se?function(t,e,n){if(je(t),e=Te(e),je(n),"function"==typeof t&&"prototype"===e&&"value"in n&&Re in n&&!n[Re]){var r=xe(t,e);r&&r[Re]&&(t[e]=n.value,n={configurable:Le in n?n[Le]:r[Le],enumerable:Ae in n?n[Ae]:r[Ae],writable:!1})}return Pe(t,e,n)}:Pe:function(t,e,n){if(je(t),e=Te(e),je(n),Oe)try{return Pe(t,e,n)}catch(t){}if("get"in n||"set"in n)throw new Ee("Accessors not supported");return"value"in n&&(t[e]=n.value),t};var Ce,Ie,ke,_e=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}},Ne=$,De=_e,Fe=r?function(t,e,n){return Ne.f(t,e,De(1,n))}:function(t,e,n){return t[e]=n,t},Me=te,Ge=Yt("keys"),Be=function(t){return Ge[t]||(Ge[t]=Me(t))},Ue={},We=q,ze=I,He=J,Ve=Fe,Ke=m,qe=M,Xe=Be,Ye=Ue,Je="Object already initialized",$e=ze.TypeError,Qe=ze.WeakMap;if(We||qe.state){var Ze=qe.state||(qe.state=new Qe);Ze.get=Ze.get,Ze.has=Ze.has,Ze.set=Ze.set,Ce=function(t,e){if(Ze.has(t))throw new $e(Je);return e.facade=t,Ze.set(t,e),e},Ie=function(t){return Ze.get(t)||{}},ke=function(t){return Ze.has(t)}}else{var tn=Xe("state");Ye[tn]=!0,Ce=function(t,e){if(Ke(t,tn))throw new $e(Je);return e.facade=t,Ve(t,tn,e),e},Ie=function(t){return Ke(t,tn)?t[tn]:{}},ke=function(t){return Ke(t,tn)}}var en={set:Ce,get:Ie,has:ke,enforce:function(t){return ke(t)?Ie(t):Ce(t,{})},getterFor:function(t){return function(e){var n;if(!He(e)||(n=Ie(e)).type!==t)throw new $e("Incompatible receiver, "+t+" required");return n}}},nn=f,rn=n,on=R,un=m,cn=r,an=E.CONFIGURABLE,fn=H,sn=en.enforce,ln=en.get,pn=String,hn=Object.defineProperty,dn=nn("".slice),vn=nn("".replace),yn=nn([].join),gn=cn&&!rn((function(){return 8!==hn((function(){}),"length",{value:8}).length})),bn=String(String).split("String"),mn=P.exports=function(t,e,n){"Symbol("===dn(pn(e),0,7)&&(e="["+vn(pn(e),/^Symbol\(([^)]*)\)/,"$1")+"]"),n&&n.getter&&(e="get "+e),n&&n.setter&&(e="set "+e),(!un(t,"name")||an&&t.name!==e)&&(cn?hn(t,"name",{value:e,configurable:!0}):t.name=e),gn&&n&&un(n,"arity")&&t.length!==n.arity&&hn(t,"length",{value:n.arity});try{n&&un(n,"constructor")&&n.constructor?cn&&hn(t,"prototype",{writable:!1}):t.prototype&&(t.prototype=void 0)}catch(t){}var r=sn(t);return un(r,"source")||(r.source=yn(bn,"string"==typeof e?e:"")),t};Function.prototype.toString=mn((function(){return on(this)&&ln(this).source||fn(this)}),"toString");var wn=P.exports,On=wn,Sn=$,jn=function(t,e,n){return n.get&&On(n.get,e,{getter:!0}),n.set&&On(n.set,e,{setter:!0}),Sn.f(t,e,n)},Tn=r,En=E.EXISTS,Pn=f,xn=jn,An=Function.prototype,Ln=Pn(An.toString),Rn=/function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/,Cn=Pn(Rn.exec);Tn&&!En&&xn(An,"name",{configurable:!0,get:function(){try{return Cn(Rn,Ln(this))[1]}catch(t){return""}}});var In={},kn={},_n={}.propertyIsEnumerable,Nn=Object.getOwnPropertyDescriptor,Dn=Nn&&!_n.call({1:2},1);kn.f=Dn?function(t){var e=Nn(this,t);return!!e&&e.enumerable}:_n;var Fn=f,Mn=Fn({}.toString),Gn=Fn("".slice),Bn=function(t){return Gn(Mn(t),8,-1)},Un=n,Wn=Bn,zn=Object,Hn=f("".split),Vn=Un((function(){return!zn("z").propertyIsEnumerable(0)}))?function(t){return"String"===Wn(t)?Hn(t,""):zn(t)}:zn,Kn=Vn,qn=h,Xn=function(t){return Kn(qn(t))},Yn=r,Jn=lt,$n=kn,Qn=_e,Zn=Xn,tr=me,er=m,nr=rt,rr=Object.getOwnPropertyDescriptor;In.f=Yn?rr:function(t,e){if(t=Zn(t),e=tr(e),nr)try{return rr(t,e)}catch(t){}if(er(t,e))return Qn(!Jn($n.f,t,e),t[e])};var or=R,ir=$,ur=wn,cr=N,ar=function(t,e,n,r){r||(r={});var o=r.enumerable,i=void 0!==r.name?r.name:e;if(or(n)&&ur(n,i,r),r.global)o?t[e]=n:cr(e,n);else{try{r.unsafe?t[e]&&(o=!0):delete t[e]}catch(t){}o?t[e]=n:ir.f(t,e,{value:n,enumerable:!1,configurable:!r.nonConfigurable,writable:!r.nonWritable})}return t},fr={},sr=Math.ceil,lr=Math.floor,pr=Math.trunc||function(t){var e=+t;return(e>0?lr:sr)(e)},hr=function(t){var e=+t;return e!=e||0===e?0:pr(e)},dr=hr,vr=Math.max,yr=Math.min,gr=function(t,e){var n=dr(t);return n<0?vr(n+e,0):yr(n,e)},br=hr,mr=Math.min,wr=function(t){return t>0?mr(br(t),9007199254740991):0},Or=function(t){return wr(t.length)},Sr=Xn,jr=gr,Tr=Or,Er=function(t){return function(e,n,r){var o,i=Sr(e),u=Tr(i),c=jr(r,u);if(t&&n!=n){for(;u>c;)if((o=i[c++])!=o)return!0}else for(;u>c;c++)if((t||c in i)&&i[c]===n)return t||c||0;return!t&&-1}},Pr={includes:Er(!0),indexOf:Er(!1)},xr=m,Ar=Xn,Lr=Pr.indexOf,Rr=Ue,Cr=f([].push),Ir=function(t,e){var n,r=Ar(t),o=0,i=[];for(n in r)!xr(Rr,n)&&xr(r,n)&&Cr(i,n);for(;e.length>o;)xr(r,n=e[o++])&&(~Lr(i,n)||Cr(i,n));return i},kr=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],_r=Ir,Nr=kr.concat("length","prototype");fr.f=Object.getOwnPropertyNames||function(t){return _r(t,Nr)};var Dr={};Dr.f=Object.getOwnPropertySymbols;var Fr=dt,Mr=fr,Gr=Dr,Br=at,Ur=f([].concat),Wr=Fr("Reflect","ownKeys")||function(t){var e=Mr.f(Br(t)),n=Gr.f;return n?Ur(e,n(t)):e},zr=m,Hr=Wr,Vr=In,Kr=$,qr=n,Xr=R,Yr=/#|\.prototype\./,Jr=function(t,e){var n=Qr[$r(t)];return n===to||n!==Zr&&(Xr(e)?qr(e):!!e)},$r=Jr.normalize=function(t){return String(t).replace(Yr,".").toLowerCase()},Qr=Jr.data={},Zr=Jr.NATIVE="N",to=Jr.POLYFILL="P",eo=Jr,no=I,ro=In.f,oo=Fe,io=ar,uo=N,co=function(t,e,n){for(var r=Hr(e),o=Kr.f,i=Vr.f,u=0;uo;)for(var c,a=So(arguments[o++]),f=i?Eo(bo(a),i(a)):bo(a),s=f.length,l=0;s>l;)c=f[l++],ho&&!yo(u,a,c)||(n[c]=a[c]);return n}:jo,xo=Po;fo({target:"Object",stat:!0,arity:2,forced:Object.assign!==xo},{assign:xo});var Ao={};Ao[fe("toStringTag")]="z";var Lo="[object z]"===String(Ao),Ro=Lo,Co=R,Io=Bn,ko=fe("toStringTag"),_o=Object,No="Arguments"===Io(function(){return arguments}()),Do=Ro?Io:function(t){var e,n,r;return void 0===t?"Undefined":null===t?"Null":"string"==typeof(n=function(t,e){try{return t[e]}catch(t){}}(e=_o(t),ko))?n:No?Io(e):"Object"===(r=Io(e))&&Co(e.callee)?"Arguments":r},Fo=Do,Mo=Lo?{}.toString:function(){return"[object "+Fo(this)+"]"};Lo||ar(Object.prototype,"toString",Mo,{unsafe:!0});var Go="process"===Bn(I.process),Bo=f,Uo=Gt,Wo=R,zo=String,Ho=TypeError,Vo=function(t,e,n){try{return Bo(Uo(Object.getOwnPropertyDescriptor(t,e)[n]))}catch(t){}},Ko=at,qo=function(t){if("object"==typeof t||Wo(t))return t;throw new Ho("Can't set "+zo(t)+" as a prototype")},Xo=Object.setPrototypeOf||("__proto__"in{}?function(){var t,e=!1,n={};try{(t=Vo(Object.prototype,"__proto__","set"))(n,[]),e=n instanceof Array}catch(t){}return function(n,r){return Ko(n),qo(r),e?t(n,r):n.__proto__=r,n}}():void 0),Yo=$.f,Jo=m,$o=fe("toStringTag"),Qo=function(t,e,n){t&&!n&&(t=t.prototype),t&&!Jo(t,$o)&&Yo(t,$o,{configurable:!0,value:e})},Zo=dt,ti=jn,ei=r,ni=fe("species"),ri=vt,oi=TypeError,ii=function(t,e){if(ri(e,t))return t;throw new oi("Incorrect invocation")},ui=f,ci=n,ai=R,fi=Do,si=H,li=function(){},pi=[],hi=dt("Reflect","construct"),di=/^\s*(?:class|function)\b/,vi=ui(di.exec),yi=!di.test(li),gi=function(t){if(!ai(t))return!1;try{return hi(li,pi,t),!0}catch(t){return!1}},bi=function(t){if(!ai(t))return!1;switch(fi(t)){case"AsyncFunction":case"GeneratorFunction":case"AsyncGeneratorFunction":return!1}try{return yi||!!vi(di,si(t))}catch(t){return!0}};bi.sham=!0;var mi,wi,Oi,Si,ji=!hi||ci((function(){var t;return gi(gi.call)||!gi(Object)||!gi((function(){t=!0}))||t}))?bi:gi,Ti=ji,Ei=Nt,Pi=TypeError,xi=at,Ai=function(t){if(Ti(t))return t;throw new Pi(Ei(t)+" is not a constructor")},Li=s,Ri=fe("species"),Ci=o,Ii=Function.prototype,ki=Ii.apply,_i=Ii.call,Ni="object"==typeof Reflect&&Reflect.apply||(Ci?_i.bind(ki):function(){return _i.apply(ki,arguments)}),Di=Bn,Fi=f,Mi=function(t){if("Function"===Di(t))return Fi(t)},Gi=Gt,Bi=o,Ui=Mi(Mi.bind),Wi=function(t,e){return Gi(t),void 0===e?t:Bi?Ui(t,e):function(){return t.apply(e,arguments)}},zi=dt("document","documentElement"),Hi=f([].slice),Vi=TypeError,Ki=/(?:ipad|iphone|ipod).*applewebkit/i.test(yt),qi=I,Xi=Ni,Yi=Wi,Ji=R,$i=m,Qi=n,Zi=zi,tu=Hi,eu=et,nu=function(t,e){if(ti;i++)if((c=g(t[i]))&&Da(Wa,c))return c;return new Ua(!1)}r=Fa(t,o)}for(a=p?t.next:r.next;!(f=Ca(a,r)).done;){try{c=g(f.value)}catch(t){Ga(r,"throw",t)}if("object"==typeof c&&c&&Da(Wa,c))return c}return new Ua(!1)},Ha=fe("iterator"),Va=!1;try{var Ka=0,qa={next:function(){return{done:!!Ka++}},return:function(){Va=!0}};qa[Ha]=function(){return this},Array.from(qa,(function(){throw 2}))}catch(t){}var Xa=function(t,e){try{if(!e&&!Va)return!1}catch(t){return!1}var n=!1;try{var r={};r[Ha]=function(){return{next:function(){return{done:n=!0}}}},t(r)}catch(t){}return n},Ya=Xu,Ja=sc.CONSTRUCTOR||!Xa((function(t){Ya.all(t).then(void 0,(function(){}))})),$a=lt,Qa=Gt,Za=lc,tf=qu,ef=za;fo({target:"Promise",stat:!0,forced:Ja},{all:function(t){var e=this,n=Za.f(e),r=n.resolve,o=n.reject,i=tf((function(){var n=Qa(e.resolve),i=[],u=0,c=1;ef(t,(function(t){var a=u++,f=!1;c++,$a(n,e,t).then((function(t){f||(f=!0,i[a]=t,--c||r(i))}),o)})),--c||r(i)}));return i.error&&o(i.value),n.promise}});var nf=fo,rf=sc.CONSTRUCTOR,of=Xu,uf=dt,cf=R,af=ar,ff=of&&of.prototype;if(nf({target:"Promise",proto:!0,forced:rf,real:!0},{catch:function(t){return this.then(void 0,t)}}),cf(of)){var sf=uf("Promise").prototype.catch;ff.catch!==sf&&af(ff,"catch",sf,{unsafe:!0})}var lf=lt,pf=Gt,hf=lc,df=qu,vf=za;fo({target:"Promise",stat:!0,forced:Ja},{race:function(t){var e=this,n=hf.f(e),r=n.reject,o=df((function(){var o=pf(e.resolve);vf(t,(function(t){lf(o,e,t).then(n.resolve,r)}))}));return o.error&&r(o.value),n.promise}});var yf=lt,gf=lc;fo({target:"Promise",stat:!0,forced:sc.CONSTRUCTOR},{reject:function(t){var e=gf.f(this);return yf(e.reject,void 0,t),e.promise}});var bf=at,mf=J,wf=lc,Of=fo,Sf=sc.CONSTRUCTOR,jf=function(t,e){if(bf(t),mf(e)&&e.constructor===t)return e;var n=wf.f(t);return(0,n.resolve)(e),n.promise};dt("Promise"),Of({target:"Promise",stat:!0,forced:Sf},{resolve:function(t){return jf(this,t)}});var Tf=n,Ef=function(t,e){var n=[][t];return!!n&&Tf((function(){n.call(null,e||function(){return 1},1)}))},Pf=fo,xf=Vn,Af=Xn,Lf=Ef,Rf=f([].join);Pf({target:"Array",proto:!0,forced:xf!==Object||!Lf("join",",")},{join:function(t){return Rf(Af(this),void 0===t?",":t)}});var Cf={},If=r,kf=ot,_f=$,Nf=at,Df=Xn,Ff=po;Cf.f=If&&!kf?Object.defineProperties:function(t,e){Nf(t);for(var n,r=Df(e),o=Ff(e),i=o.length,u=0;i>u;)_f.f(t,n=o[u++],r[n]);return t};var Mf,Gf=at,Bf=Cf,Uf=kr,Wf=Ue,zf=zi,Hf=et,Vf="prototype",Kf="script",qf=Be("IE_PROTO"),Xf=function(){},Yf=function(t){return"<"+Kf+">"+t+""},Jf=function(t){t.write(Yf("")),t.close();var e=t.parentWindow.Object;return t=null,e},$f=function(){try{Mf=new ActiveXObject("htmlfile")}catch(t){}var t,e,n;$f="undefined"!=typeof document?document.domain&&Mf?Jf(Mf):(e=Hf("iframe"),n="java"+Kf+":",e.style.display="none",zf.appendChild(e),e.src=String(n),(t=e.contentWindow.document).open(),t.write(Yf("document.F=Object")),t.close(),t.F):Jf(Mf);for(var r=Uf.length;r--;)delete $f[Vf][Uf[r]];return $f()};Wf[qf]=!0;var Qf=Object.create||function(t,e){var n;return null!==t?(Xf[Vf]=Gf(t),n=new Xf,Xf[Vf]=null,n[qf]=t):n=$f(),void 0===e?n:Bf.f(n,e)},Zf=fe,ts=Qf,es=$.f,ns=Zf("unscopables"),rs=Array.prototype;void 0===rs[ns]&&es(rs,ns,{configurable:!0,value:ts(null)});var os,is,us,cs=!n((function(){function t(){}return t.prototype.constructor=null,Object.getPrototypeOf(new t)!==t.prototype})),as=m,fs=R,ss=y,ls=cs,ps=Be("IE_PROTO"),hs=Object,ds=hs.prototype,vs=ls?hs.getPrototypeOf:function(t){var e=ss(t);if(as(e,ps))return e[ps];var n=e.constructor;return fs(n)&&e instanceof n?n.prototype:e instanceof hs?ds:null},ys=n,gs=R,bs=J,ms=vs,ws=ar,Os=fe("iterator"),Ss=!1;[].keys&&("next"in(us=[].keys())?(is=ms(ms(us)))!==Object.prototype&&(os=is):Ss=!0);var js=!bs(os)||ys((function(){var t={};return os[Os].call(t)!==t}));js&&(os={}),gs(os[Os])||ws(os,Os,(function(){return this}));var Ts={IteratorPrototype:os,BUGGY_SAFARI_ITERATORS:Ss},Es=Ts.IteratorPrototype,Ps=Qf,xs=_e,As=Qo,Ls=la,Rs=function(){return this},Cs=fo,Is=lt,ks=R,_s=function(t,e,n,r){var o=e+" Iterator";return t.prototype=Ps(Es,{next:xs(+!r,n)}),As(t,o,!1),Ls[o]=Rs,t},Ns=vs,Ds=Xo,Fs=Qo,Ms=Fe,Gs=ar,Bs=la,Us=E.PROPER,Ws=E.CONFIGURABLE,zs=Ts.IteratorPrototype,Hs=Ts.BUGGY_SAFARI_ITERATORS,Vs=fe("iterator"),Ks="keys",qs="values",Xs="entries",Ys=function(){return this},Js=function(t,e,n,r,o,i,u){_s(n,e,r);var c,a,f,s=function(t){if(t===o&&v)return v;if(!Hs&&t&&t in h)return h[t];switch(t){case Ks:case qs:case Xs:return function(){return new n(this,t)}}return function(){return new n(this)}},l=e+" Iterator",p=!1,h=t.prototype,d=h[Vs]||h["@@iterator"]||o&&h[o],v=!Hs&&d||s(o),y="Array"===e&&h.entries||d;if(y&&(c=Ns(y.call(new t)))!==Object.prototype&&c.next&&(Ns(c)!==zs&&(Ds?Ds(c,zs):ks(c[Vs])||Gs(c,Vs,Ys)),Fs(c,l,!0)),Us&&o===qs&&d&&d.name!==qs&&(Ws?Ms(h,"name",qs):(p=!0,v=function(){return Is(d,this)})),o)if(a={values:s(qs),keys:i?v:s(Ks),entries:s(Xs)},u)for(f in a)(Hs||p||!(f in h))&&Gs(h,f,a[f]);else Cs({target:e,proto:!0,forced:Hs||p},a);return h[Vs]!==v&&Gs(h,Vs,v,{name:o}),Bs[e]=v,a},$s=function(t,e){return{value:t,done:e}},Qs=Xn,Zs=function(t){rs[ns][t]=!0},tl=la,el=en,nl=$.f,rl=Js,ol=$s,il=r,ul="Array Iterator",cl=el.set,al=el.getterFor(ul),fl=rl(Array,"Array",(function(t,e){cl(this,{type:ul,target:Qs(t),index:0,kind:e})}),(function(){var t=al(this),e=t.target,n=t.index++;if(!e||n>=e.length)return t.target=void 0,ol(void 0,!0);switch(t.kind){case"keys":return ol(n,!1);case"values":return ol(e[n],!1)}return ol([n,e[n]],!1)}),"values"),sl=tl.Arguments=tl.Array;if(Zs("keys"),Zs("values"),Zs("entries"),il&&"values"!==sl.name)try{nl(sl,"name",{value:"values"})}catch(t){}var ll=Do,pl=String,hl=function(t){if("Symbol"===ll(t))throw new TypeError("Cannot convert a Symbol value to a string");return pl(t)},dl=f,vl=hr,yl=hl,gl=h,bl=dl("".charAt),ml=dl("".charCodeAt),wl=dl("".slice),Ol=function(t){return function(e,n){var r,o,i=yl(gl(e)),u=vl(n),c=i.length;return u<0||u>=c?t?"":void 0:(r=ml(i,u))<55296||r>56319||u+1===c||(o=ml(i,u+1))<56320||o>57343?t?bl(i,u):r:t?wl(i,u,u+2):o-56320+(r-55296<<10)+65536}},Sl={codeAt:Ol(!1),charAt:Ol(!0)}.charAt,jl=hl,Tl=en,El=Js,Pl=$s,xl="String Iterator",Al=Tl.set,Ll=Tl.getterFor(xl);El(String,"String",(function(t){Al(this,{type:xl,string:jl(t),index:0})}),(function(){var t,e=Ll(this),n=e.string,r=e.index;return r>=n.length?Pl(void 0,!0):(t=Sl(n,r),e.index+=t.length,Pl(t,!1))}));var Rl={exports:{}},Cl={},Il=me,kl=$,_l=_e,Nl=gr,Dl=Or,Fl=function(t,e,n){var r=Il(e);r in t?kl.f(t,r,_l(0,n)):t[r]=n},Ml=Array,Gl=Math.max,Bl=Bn,Ul=Xn,Wl=fr.f,zl=function(t,e,n){for(var r=Dl(t),o=Nl(e,r),i=Nl(void 0===n?r:n,r),u=Ml(Gl(i-o,0)),c=0;ob;b++)if((c||b in v)&&(h=g(p=v[b],b,d),t))if(e)w[b]=h;else if(h)switch(t){case 3:return!0;case 5:return p;case 6:return b;case 2:Kp(w,p)}else switch(t){case 4:return!1;case 7:Kp(w,p)}return i?-1:r||o?o:w}},Xp={forEach:qp(0),map:qp(1),filter:qp(2),some:qp(3),every:qp(4),find:qp(5),findIndex:qp(6),filterReject:qp(7)},Yp=f,Jp=function(t,e,n){for(var r in e)kp(t,r,e[r],n);return t},$p=dp.getWeakData,Qp=ii,Zp=at,th=s,eh=J,nh=za,rh=m,oh=en.set,ih=en.getterFor,uh=Xp.find,ch=Xp.findIndex,ah=Yp([].splice),fh=0,sh=function(t){return t.frozen||(t.frozen=new lh)},lh=function(){this.entries=[]},ph=function(t,e){return uh(t.entries,(function(t){return t[0]===e}))};lh.prototype={get:function(t){var e=ph(this,t);if(e)return e[1]},has:function(t){return!!ph(this,t)},set:function(t,e){var n=ph(this,t);n?n[1]=e:this.entries.push([t,e])},delete:function(t){var e=ch(this.entries,(function(e){return e[0]===t}));return~e&&ah(this.entries,e,1),!!~e}};var hh={getConstructor:function(t,e,n,r){var o=t((function(t,o){Qp(t,i),oh(t,{type:e,id:fh++,frozen:void 0}),th(o)||nh(o,t[r],{that:t,AS_ENTRIES:n})})),i=o.prototype,u=ih(e),c=function(t,e,n){var r=u(t),o=$p(Zp(e),!0);return!0===o?sh(r).set(e,n):o[r.id]=n,t};return Jp(i,{delete:function(t){var e=u(this);if(!eh(t))return!1;var n=$p(t);return!0===n?sh(e).delete(t):n&&rh(n,e.id)&&delete n[e.id]},has:function(t){var e=u(this);if(!eh(t))return!1;var n=$p(t);return!0===n?sh(e).has(t):n&&rh(n,e.id)}}),Jp(i,n?{get:function(t){var e=u(this);if(eh(t)){var n=$p(t);return!0===n?sh(e).get(t):n?n[e.id]:void 0}},set:function(t,e){return c(this,t,e)}}:{add:function(t){return c(this,t,!0)}}),o}};(function(t,e,n){var r=-1!==t.indexOf("Map"),o=-1!==t.indexOf("Weak"),i=r?"set":"add",u=mp[t],c=u&&u.prototype,a=u,f={},s=function(t){var e=wp(c[t]);Sp(c,t,"add"===t?function(t){return e(this,0===t?0:t),this}:"delete"===t?function(t){return!(o&&!Ap(t))&&e(this,0===t?0:t)}:"get"===t?function(t){return o&&!Ap(t)?void 0:e(this,0===t?0:t)}:"has"===t?function(t){return!(o&&!Ap(t))&&e(this,0===t?0:t)}:function(t,n){return e(this,0===t?0:t,n),this})};if(Op(t,!Pp(u)||!(o||c.forEach&&!Lp((function(){(new u).entries().next()})))))a=n.getConstructor(e,t,r,i),jp.enable();else if(Op(t,!0)){var l=new a,p=l[i](o?{}:-0,1)!==l,h=Lp((function(){l.has(1)})),d=Rp((function(t){new u(t)})),v=!o&&Lp((function(){for(var t=new u,e=5;e--;)t[i](e,e);return!t.has(-0)}));d||((a=e((function(t,e){Ep(t,c);var n=Ip(new u,t,a);return xp(e)||Tp(e,n[i],{that:n,AS_ENTRIES:r}),n}))).prototype=c,c.constructor=a),(h||v)&&(s("delete"),s("has"),r&&s("get")),(v||p)&&s(i),o&&c.clear&&delete c.clear}f[t]=a,bp({global:!0,constructor:!0,forced:a!==u},f),Cp(a,t),o||n.setStrong(a,t,r)})("WeakSet",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),hh);var dh={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0},vh=et("span").classList,yh=vh&&vh.constructor&&vh.constructor.prototype,gh=yh===Object.prototype?void 0:yh,bh=I,mh=dh,wh=gh,Oh=fl,Sh=Fe,jh=Qo,Th=fe("iterator"),Eh=Oh.values,Ph=function(t,e){if(t){if(t[Th]!==Eh)try{Sh(t,Th,Eh)}catch(e){t[Th]=Eh}if(jh(t,e,!0),mh[e])for(var n in Oh)if(t[n]!==Oh[n])try{Sh(t,n,Oh[n])}catch(e){t[n]=Oh[n]}}};for(var xh in mh)Ph(bh[xh]&&bh[xh].prototype,xh);Ph(wh,"DOMTokenList");var Ah=Xp.forEach,Lh=Ef("forEach")?[].forEach:function(t){return Ah(this,t,arguments.length>1?arguments[1]:void 0)},Rh=I,Ch=dh,Ih=gh,kh=Lh,_h=Fe,Nh=function(t){if(t&&t.forEach!==kh)try{_h(t,"forEach",kh)}catch(e){t.forEach=kh}};for(var Dh in Ch)Ch[Dh]&&Nh(Rh[Dh]&&Rh[Dh].prototype);Nh(Ih);var Fh,Mh,Gh,Bh,Uh,Wh,zh,Hh,Vh,Kh,qh=y,Xh=po;function Yh(t,e,n,r){if("a"===n&&!r)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof e?t!==e||!r:!e.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===n?r:"a"===n?r.call(t):r?r.value:e.get(t)}function Jh(t){return"top"===t||"bottom"===t}function $h(t){return t[Mh.LEFT]+t[Mh.RIGHT]}function Qh(t){return t[Mh.TOP]+t[Mh.BOTTOM]}fo({target:"Object",stat:!0,forced:n((function(){Xh(1)}))},{keys:function(t){return Xh(qh(t))}}),function(t){t[t.SCROLL_NONE=0]="SCROLL_NONE",t[t.SCROLL_BACKWARD=1]="SCROLL_BACKWARD",t[t.SCROLL_FORWARD=2]="SCROLL_FORWARD"}(Fh||(Fh={})),function(t){t[t.TOP=0]="TOP",t[t.RIGHT=1]="RIGHT",t[t.BOTTOM=2]="BOTTOM",t[t.LEFT=3]="LEFT"}(Mh||(Mh={}));var Zh=".ch-plugin-calendar-label",td={enabled:!0,dimensions:{width:0,height:0},position:"left",text:function(){return[]},padding:[0,0,0,0]},ed=function(){function e(t){var n,r;!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,e),Gh.add(this),this.name="CalendarLabel";var o=null===(r=null===(n=null==t?void 0:t.options)||void 0===n?void 0:n.options)||void 0===r?void 0:r.subDomain;this.calendar=t,this.root=null,this.shown=!1,this.options=td,this.computedOptions={radius:null==o?void 0:o.radius,width:null==o?void 0:o.width,height:null==o?void 0:o.height,gutter:null==o?void 0:o.gutter,textAlign:"start"}}var n,r,o;return n=e,(r=[{key:"setup",value:function(t){this.options=Object.assign(Object.assign({},td),t)}},{key:"paint",value:function(){if(!this.options.enabled)return this.destroy();this.shown=!0;var t=this.calendar.calendarPainter.root;return this.root||(this.root=t.append("svg").attr("class",Zh.slice(1)).attr("data-key",this.options.key).attr("x",0).attr("y",0)),this.build(),Promise.resolve()}},{key:"destroy",value:function(){return null!==this.root&&(this.root.remove(),this.root=null),Promise.resolve()}},{key:"build",value:function(){var t=this;return Yh(this,Gh,"m",Bh).call(this),Yh(this,Gh,"m",Uh).call(this),this.root.selectAll("g").data(this.options.text).join((function(e){return e.append("g").call((function(e){return e.append("rect").attr("class","".concat(Zh.slice(1),"-bg")).attr("style","fill: transparent").call((function(e){return Yh(t,Gh,"m",Wh).call(t,e)}))})).call((function(e){return e.append("text").attr("class","".concat(Zh.slice(1),"-text")).attr("dominant-baseline","central").attr("text-anchor","middle").attr("style","fill: currentColor; font-size: 10px").call((function(e){return Yh(t,Gh,"m",zh).call(t,e)}))}))})),Promise.resolve()}}])&&t(n.prototype,r),o&&t(n,o),Object.defineProperty(n,"prototype",{writable:!1}),e}();return Gh=new WeakSet,Bh=function(){var t=this;Object.keys(this.computedOptions).forEach((function(e){void 0!==t.options[e]&&(t.computedOptions[e]=t.options[e])}))},Uh=function(){var t=this.computedOptions,e=t.width,n=t.height,r=t.gutter,o=this.options,i=o.text,u=o.padding,c=o.position,a=i().length;this.options.dimensions={width:e+$h(u),height:n+Qh(u)},Jh(c)?this.options.dimensions.width+=(e+r)*(a-1):this.options.dimensions.height+=(n+r)*(a-1)},Wh=function(t){var e=this,n=this.computedOptions,r=n.width,o=n.height,i=n.radius;t.attr("width",r).attr("height",o).attr("rx",i&&i>0?i:null).attr("ry",i&&i>0?i:null).attr("x",(function(t,n){return Yh(e,Gh,"m",Vh).call(e,n)})).attr("y",(function(t,n){return Yh(e,Gh,"m",Kh).call(e,n)}))},zh=function(t){var e=this,n=this.computedOptions,r=n.height,o=n.textAlign;t.attr("text-anchor",o).attr("x",(function(t,n){return Yh(e,Gh,"m",Hh).call(e)+Yh(e,Gh,"m",Vh).call(e,n)})).attr("y",(function(t,n){return Yh(e,Gh,"m",Kh).call(e,n)+r/2})).text((function(t){return t}))},Hh=function(){var t=this.computedOptions,e=t.width;switch(t.textAlign){case"start":default:return 0;case"middle":return e/2;case"end":return e}},Vh=function(t){var e=this.options,n=e.position,r=e.padding,o=this.computedOptions,i=o.width,u=o.gutter;return function(t){return"left"===t||"right"===t}(n)?r[Mh.LEFT]:r[Mh.LEFT]+(i+u)*t},Kh=function(t){var e=this.options,n=e.position,r=e.padding,o=this.computedOptions,i=o.height,u=o.gutter;return Jh(n)?r[Mh.TOP]:r[Mh.TOP]+(i+u)*t},ed}));//# sourceMappingURL=CalendarLabel.min.js.map diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.js.map b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.js.map new file mode 100644 index 0000000..dbabc62 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/CalendarLabel.min.js.map @@ -0,0 +1 @@ +{"version":3,"file":"CalendarLabel.min.js","sources":["../../node_modules/core-js/internals/fails.js","../../node_modules/core-js/internals/descriptors.js","../../node_modules/core-js/internals/function-bind-native.js","../../node_modules/core-js/internals/function-uncurry-this.js","../../node_modules/core-js/internals/is-null-or-undefined.js","../../node_modules/core-js/internals/require-object-coercible.js","../../node_modules/core-js/internals/to-object.js","../../node_modules/core-js/internals/has-own-property.js","../../node_modules/core-js/internals/function-name.js","../../node_modules/core-js/internals/document-all.js","../../node_modules/core-js/internals/is-callable.js","../../node_modules/core-js/internals/global.js","../../node_modules/core-js/internals/define-global-property.js","../../node_modules/core-js/internals/shared-store.js","../../node_modules/core-js/internals/inspect-source.js","../../node_modules/core-js/internals/engine-v8-version.js","../../node_modules/core-js/internals/weak-map-basic-detection.js","../../node_modules/core-js/internals/is-object.js","../../node_modules/core-js/internals/document-create-element.js","../../node_modules/core-js/internals/ie8-dom-define.js","../../node_modules/core-js/internals/v8-prototype-define-bug.js","../../node_modules/core-js/internals/an-object.js","../../node_modules/core-js/internals/function-call.js","../../node_modules/core-js/internals/get-built-in.js","../../node_modules/core-js/internals/object-is-prototype-of.js","../../node_modules/core-js/internals/engine-user-agent.js","../../node_modules/core-js/internals/symbol-constructor-detection.js","../../node_modules/core-js/internals/use-symbol-as-uid.js","../../node_modules/core-js/internals/is-symbol.js","../../node_modules/core-js/internals/try-to-string.js","../../node_modules/core-js/internals/a-callable.js","../../node_modules/core-js/internals/get-method.js","../../node_modules/core-js/internals/ordinary-to-primitive.js","../../node_modules/core-js/internals/shared.js","../../node_modules/core-js/internals/uid.js","../../node_modules/core-js/internals/well-known-symbol.js","../../node_modules/core-js/internals/to-primitive.js","../../node_modules/core-js/internals/to-property-key.js","../../node_modules/core-js/internals/object-define-property.js","../../node_modules/core-js/internals/create-property-descriptor.js","../../node_modules/core-js/internals/internal-state.js","../../node_modules/core-js/internals/create-non-enumerable-property.js","../../node_modules/core-js/internals/shared-key.js","../../node_modules/core-js/internals/hidden-keys.js","../../node_modules/core-js/internals/make-built-in.js","../../node_modules/core-js/internals/define-built-in-accessor.js","../../node_modules/core-js/modules/es.function.name.js","../../node_modules/core-js/internals/object-property-is-enumerable.js","../../node_modules/core-js/internals/classof-raw.js","../../node_modules/core-js/internals/indexed-object.js","../../node_modules/core-js/internals/to-indexed-object.js","../../node_modules/core-js/internals/object-get-own-property-descriptor.js","../../node_modules/core-js/internals/define-built-in.js","../../node_modules/core-js/internals/math-trunc.js","../../node_modules/core-js/internals/to-integer-or-infinity.js","../../node_modules/core-js/internals/to-absolute-index.js","../../node_modules/core-js/internals/to-length.js","../../node_modules/core-js/internals/length-of-array-like.js","../../node_modules/core-js/internals/array-includes.js","../../node_modules/core-js/internals/object-keys-internal.js","../../node_modules/core-js/internals/enum-bug-keys.js","../../node_modules/core-js/internals/object-get-own-property-names.js","../../node_modules/core-js/internals/object-get-own-property-symbols.js","../../node_modules/core-js/internals/own-keys.js","../../node_modules/core-js/internals/copy-constructor-properties.js","../../node_modules/core-js/internals/is-forced.js","../../node_modules/core-js/internals/export.js","../../node_modules/core-js/internals/object-keys.js","../../node_modules/core-js/internals/object-assign.js","../../node_modules/core-js/modules/es.object.assign.js","../../node_modules/core-js/internals/to-string-tag-support.js","../../node_modules/core-js/internals/classof.js","../../node_modules/core-js/internals/object-to-string.js","../../node_modules/core-js/modules/es.object.to-string.js","../../node_modules/core-js/internals/engine-is-node.js","../../node_modules/core-js/internals/function-uncurry-this-accessor.js","../../node_modules/core-js/internals/a-possible-prototype.js","../../node_modules/core-js/internals/object-set-prototype-of.js","../../node_modules/core-js/internals/set-to-string-tag.js","../../node_modules/core-js/internals/set-species.js","../../node_modules/core-js/internals/an-instance.js","../../node_modules/core-js/internals/is-constructor.js","../../node_modules/core-js/internals/task.js","../../node_modules/core-js/internals/a-constructor.js","../../node_modules/core-js/internals/species-constructor.js","../../node_modules/core-js/internals/function-apply.js","../../node_modules/core-js/internals/function-uncurry-this-clause.js","../../node_modules/core-js/internals/function-bind-context.js","../../node_modules/core-js/internals/html.js","../../node_modules/core-js/internals/array-slice.js","../../node_modules/core-js/internals/validate-arguments-length.js","../../node_modules/core-js/internals/engine-is-ios.js","../../node_modules/core-js/internals/queue.js","../../node_modules/core-js/internals/microtask.js","../../node_modules/core-js/internals/engine-is-ios-pebble.js","../../node_modules/core-js/internals/engine-is-webos-webkit.js","../../node_modules/core-js/internals/perform.js","../../node_modules/core-js/internals/promise-native-constructor.js","../../node_modules/core-js/internals/engine-is-deno.js","../../node_modules/core-js/internals/engine-is-browser.js","../../node_modules/core-js/internals/promise-constructor-detection.js","../../node_modules/core-js/internals/new-promise-capability.js","../../node_modules/core-js/modules/es.promise.constructor.js","../../node_modules/core-js/internals/host-report-errors.js","../../node_modules/core-js/internals/iterators.js","../../node_modules/core-js/internals/is-array-iterator-method.js","../../node_modules/core-js/internals/get-iterator-method.js","../../node_modules/core-js/internals/get-iterator.js","../../node_modules/core-js/internals/iterator-close.js","../../node_modules/core-js/internals/iterate.js","../../node_modules/core-js/internals/check-correctness-of-iteration.js","../../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","../../node_modules/core-js/modules/es.promise.all.js","../../node_modules/core-js/modules/es.promise.catch.js","../../node_modules/core-js/modules/es.promise.race.js","../../node_modules/core-js/modules/es.promise.reject.js","../../node_modules/core-js/internals/promise-resolve.js","../../node_modules/core-js/modules/es.promise.resolve.js","../../node_modules/core-js/internals/array-method-is-strict.js","../../node_modules/core-js/modules/es.array.join.js","../../node_modules/core-js/internals/object-define-properties.js","../../node_modules/core-js/internals/object-create.js","../../node_modules/core-js/internals/add-to-unscopables.js","../../node_modules/core-js/internals/iterators-core.js","../../node_modules/core-js/internals/correct-prototype-getter.js","../../node_modules/core-js/internals/object-get-prototype-of.js","../../node_modules/core-js/internals/iterator-create-constructor.js","../../node_modules/core-js/internals/iterator-define.js","../../node_modules/core-js/internals/create-iter-result-object.js","../../node_modules/core-js/modules/es.array.iterator.js","../../node_modules/core-js/internals/to-string.js","../../node_modules/core-js/internals/string-multibyte.js","../../node_modules/core-js/modules/es.string.iterator.js","../../node_modules/core-js/internals/create-property.js","../../node_modules/core-js/internals/array-slice-simple.js","../../node_modules/core-js/internals/object-get-own-property-names-external.js","../../node_modules/core-js/internals/array-buffer-non-extensible.js","../../node_modules/core-js/internals/object-is-extensible.js","../../node_modules/core-js/internals/freezing.js","../../node_modules/core-js/internals/internal-metadata.js","../../node_modules/core-js/internals/inherit-if-required.js","../../node_modules/core-js/internals/collection.js","../../node_modules/core-js/internals/define-built-ins.js","../../node_modules/core-js/internals/is-array.js","../../node_modules/core-js/internals/array-species-constructor.js","../../node_modules/core-js/internals/array-species-create.js","../../node_modules/core-js/internals/array-iteration.js","../../node_modules/core-js/internals/collection-weak.js","../../node_modules/core-js/modules/es.weak-set.constructor.js","../../node_modules/core-js/internals/dom-iterables.js","../../node_modules/core-js/internals/dom-token-list-prototype.js","../../node_modules/core-js/modules/web.dom-collections.iterator.js","../../node_modules/core-js/internals/array-for-each.js","../../node_modules/core-js/modules/web.dom-collections.for-each.js","../../node_modules/core-js/modules/es.object.keys.js","../../../src/constant.ts","../../node_modules/tslib/tslib.es6.js","../../../src/helpers/PositionHelper.ts","../../../src/plugins/CalendarLabel.ts"],"sourcesContent":["'use strict';\nmodule.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-function-prototype-bind -- safe\n var test = (function () { /* empty */ }).bind();\n // eslint-disable-next-line no-prototype-builtins -- safe\n return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n return function () {\n return call.apply(fn, arguments);\n };\n};\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n return it === null || it === undefined;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n return it;\n};\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar documentAll = typeof document == 'object' && document.all;\n\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nvar IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;\n\nmodule.exports = {\n all: documentAll,\n IS_HTMLDDA: IS_HTMLDDA\n};\n","'use strict';\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = $documentAll.IS_HTMLDDA ? function (argument) {\n return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n return typeof argument == 'function';\n};\n","'use strict';\nvar check = function (it) {\n return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n check(typeof this == 'object' && this) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\nmodule.exports = $documentAll.IS_HTMLDDA ? function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;\n} : function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a !== 7;\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype !== 42;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol('symbol detection');\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n // of course, fail.\n return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n try {\n return $String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.34.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',\n license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',\n source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name)) {\n WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n ? Symbol[name]\n : createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw new $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","'use strict';\nmodule.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n /* eslint-disable no-self-assign -- prototype methods protection */\n store.get = store.get;\n store.has = store.has;\n store.set = store.set;\n /* eslint-enable no-self-assign -- prototype methods protection */\n set = function (it, metadata) {\n if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n store.set(it, metadata);\n return metadata;\n };\n get = function (it) {\n return store.get(it) || {};\n };\n has = function (it) {\n return store.has(it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (options && options.getter) name = 'get ' + name;\n if (options && options.setter) name = 'set ' + name;\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n else value.name = name;\n }\n if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n defineProperty(value, 'length', { value: options.arity });\n }\n try {\n if (options && hasOwn(options, 'constructor') && options.constructor) {\n if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n } else if (value.prototype) value.prototype = undefined;\n } catch (error) { /* empty */ }\n var state = enforceInternalState(value);\n if (!hasOwn(state, 'source')) {\n state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineProperty = require('../internals/object-define-property');\n\nmodule.exports = function (target, name, descriptor) {\n if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });\n if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });\n return defineProperty.f(target, name, descriptor);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar FUNCTION_NAME_EXISTS = require('../internals/function-name').EXISTS;\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\n\nvar FunctionPrototype = Function.prototype;\nvar functionToString = uncurryThis(FunctionPrototype.toString);\nvar nameRE = /function\\b(?:\\s|\\/\\*[\\S\\s]*?\\*\\/|\\/\\/[^\\n\\r]*[\\n\\r]+)*([^\\s(/]*)/;\nvar regExpExec = uncurryThis(nameRE.exec);\nvar NAME = 'name';\n\n// Function instances `.name` property\n// https://tc39.es/ecma262/#sec-function-instances-name\nif (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {\n defineBuiltInAccessor(FunctionPrototype, NAME, {\n configurable: true,\n get: function () {\n try {\n return regExpExec(nameRE, functionToString(this))[1];\n } catch (error) {\n return '';\n }\n }\n });\n}\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- NaN check\n return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el !== el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value !== value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value === POLYFILL ? true\n : value === NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.dontCallGetSet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || defineGlobalProperty(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.dontCallGetSet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n defineBuiltIn(target, key, sourceProperty, options);\n }\n};\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol('assign detection');\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","'use strict';\nvar $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {\n assign: assign\n});\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar global = require('../internals/global');\nvar classof = require('../internals/classof-raw');\n\nmodule.exports = classof(global.process) === 'process';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nmodule.exports = function (object, key, method) {\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));\n } catch (error) { /* empty */ }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw new $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","'use strict';\n/* eslint-disable no-proto -- safe */\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (target, TAG, STATIC) {\n if (target && !STATIC) target = target.prototype;\n if (target && !hasOwn(target, TO_STRING_TAG)) {\n defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineBuiltInAccessor(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw new $TypeError('Incorrect invocation');\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.test(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n }\n try {\n // we can't check .prototype since constructors produced by .bind haven't it\n // `Function#toString` throws on some built-it function in some legacy engines\n // (for example, `DOMQuad` and similar in FF41-)\n return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n } catch (error) {\n return true;\n }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar $location, defer, channel, port;\n\nfails(function () {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n $location = global.location;\n});\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar eventListener = function (event) {\n run(event.data);\n};\n\nvar globalPostMessageDefer = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), $location.protocol + '//' + $location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(handler) {\n validateArgumentsLength(arguments.length, 1);\n var fn = isCallable(handler) ? handler : Function(handler);\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(fn, undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = eventListener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n $location && $location.protocol !== 'file:' &&\n !fails(globalPostMessageDefer)\n ) {\n defer = globalPostMessageDefer;\n global.addEventListener('message', eventListener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","'use strict';\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a constructor');\n};\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","'use strict';\nvar classofRaw = require('../internals/classof-raw');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (fn) {\n // Nashorn bug:\n // https://github.com/zloirock/core-js/issues/1128\n // https://github.com/zloirock/core-js/issues/1130\n if (classofRaw(fn) === 'Function') return uncurryThis(fn);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","'use strict';\nvar $TypeError = TypeError;\n\nmodule.exports = function (passed, required) {\n if (passed < required) throw new $TypeError('Not enough arguments');\n return passed;\n};\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line redos/no-vulnerable -- safe\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","'use strict';\nvar Queue = function () {\n this.head = null;\n this.tail = null;\n};\n\nQueue.prototype = {\n add: function (item) {\n var entry = { item: item, next: null };\n var tail = this.tail;\n if (tail) tail.next = entry;\n else this.head = entry;\n this.tail = entry;\n },\n get: function () {\n var entry = this.head;\n if (entry) {\n var next = this.head = entry.next;\n if (next === null) this.tail = null;\n return entry.item;\n }\n }\n};\n\nmodule.exports = Queue;\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar Queue = require('../internals/queue');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar microtask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\nvar notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!microtask) {\n var queue = new Queue();\n\n var flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (fn = queue.get()) try {\n fn();\n } catch (error) {\n if (queue.head) notify();\n throw error;\n }\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessage\n // - onreadystatechange\n // - setTimeout\n } else {\n // `webpack` dev server bug on IE global methods - use bind(fn, global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n\n microtask = function (fn) {\n if (!queue.head) notify();\n queue.add(fn);\n };\n}\n\nmodule.exports = microtask;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","'use strict';\nvar global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n && typeof window == 'object'\n && typeof document == 'object';\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n // Detect correctness of subclassing with @@species support\n var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar $TypeError = TypeError;\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar IS_NODE = require('../internals/engine-is-node');\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar perform = require('../internals/perform');\nvar Queue = require('../internals/queue');\nvar InternalStateModule = require('../internals/internal-state');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar PromiseConstructorDetection = require('../internals/promise-constructor-detection');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\n\nvar PROMISE = 'Promise';\nvar FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;\nvar NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;\nvar NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar PromiseConstructor = NativePromiseConstructor;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar callReaction = function (reaction, state) {\n var value = state.value;\n var ok = state.state === FULFILLED;\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(new TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n microtask(function () {\n var reactions = state.reactions;\n var reaction;\n while (reaction = reactions.get()) {\n callReaction(reaction, state);\n }\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw new TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED_PROMISE_CONSTRUCTOR) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalPromiseState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n\n PromisePrototype = PromiseConstructor.prototype;\n\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: new Queue(),\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n state.parent = true;\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n if (state.state === PENDING) state.reactions.add(reaction);\n else microtask(function () {\n callReaction(reaction, state);\n });\n return reaction.promise;\n });\n\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalPromiseState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!NATIVE_PROMISE_SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n","'use strict';\nmodule.exports = function (a, b) {\n try {\n // eslint-disable-next-line no-console -- safe\n arguments.length === 1 ? console.error(a) : console.error(a, b);\n } catch (error) { /* empty */ }\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw new $TypeError(tryToString(argument) + ' is not iterable');\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_RECORD = !!(options && options.IS_RECORD);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_RECORD) {\n iterator = iterable.iterator;\n } else if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = IS_RECORD ? iterable.next : iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n try {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n } catch (error) { return false; } // workaround of old WebKit + `eval` bug\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.all` method\n// https://tc39.es/ecma262/#sec-promise.all\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar defineBuiltIn = require('../internals/define-built-in');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\n\n// `Promise.prototype.catch` method\n// https://tc39.es/ecma262/#sec-promise.prototype.catch\n$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n});\n\n// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromiseConstructor)) {\n var method = getBuiltIn('Promise').prototype['catch'];\n if (NativePromisePrototype['catch'] !== method) {\n defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.race` method\n// https://tc39.es/ecma262/#sec-promise.race\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\n// `Promise.reject` method\n// https://tc39.es/ecma262/#sec-promise.reject\n$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n reject: function reject(r) {\n var capability = newPromiseCapabilityModule.f(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar promiseResolve = require('../internals/promise-resolve');\n\nvar PromiseConstructorWrapper = getBuiltIn('Promise');\nvar CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;\n\n// `Promise.resolve` method\n// https://tc39.es/ecma262/#sec-promise.resolve\n$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {\n resolve: function resolve(x) {\n return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = function (METHOD_NAME, argument) {\n var method = [][METHOD_NAME];\n return !!method && fails(function () {\n // eslint-disable-next-line no-useless-call -- required for testing\n method.call(null, argument || function () { return 1; }, 1);\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar nativeJoin = uncurryThis([].join);\n\nvar ES3_STRINGS = IndexedObject !== Object;\nvar FORCED = ES3_STRINGS || !arrayMethodIsStrict('join', ',');\n\n// `Array.prototype.join` method\n// https://tc39.es/ecma262/#sec-array.prototype.join\n$({ target: 'Array', proto: true, forced: FORCED }, {\n join: function join(separator) {\n return nativeJoin(toIndexedObject(this), separator === undefined ? ',' : separator);\n }\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var props = toIndexedObject(Properties);\n var keys = objectKeys(Properties);\n var length = keys.length;\n var index = 0;\n var key;\n while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n return O;\n};\n","'use strict';\n/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n activeXDocument.write(scriptTag(''));\n activeXDocument.close();\n var temp = activeXDocument.parentWindow.Object;\n activeXDocument = null; // avoid memory leak\n return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = documentCreateElement('iframe');\n var JS = 'java' + SCRIPT + ':';\n var iframeDocument;\n iframe.style.display = 'none';\n html.appendChild(iframe);\n // https://github.com/zloirock/core-js/issues/475\n iframe.src = String(JS);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(scriptTag('document.F=Object'));\n iframeDocument.close();\n return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n try {\n activeXDocument = new ActiveXObject('htmlfile');\n } catch (error) { /* ignore */ }\n NullProtoObject = typeof document != 'undefined'\n ? document.domain && activeXDocument\n ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n : NullProtoObjectViaIFrame()\n : NullProtoObjectViaActiveX(activeXDocument); // WSH\n var length = enumBugKeys.length;\n while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n EmptyConstructor[PROTOTYPE] = anObject(O);\n result = new EmptyConstructor();\n EmptyConstructor[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = NullProtoObject();\n return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] === undefined) {\n defineProperty(ArrayPrototype, UNSCOPABLES, {\n configurable: true,\n value: create(null)\n });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n arrayIterator = [].keys();\n // Safari 8 has buggy iterators w/o `next`\n if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n else {\n PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {\n var test = {};\n // FF44- legacy iterators case\n return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n defineBuiltIn(IteratorPrototype, ITERATOR, function () {\n return this;\n });\n}\n\nmodule.exports = {\n IteratorPrototype: IteratorPrototype,\n BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n function F() { /* empty */ }\n F.prototype.constructor = null;\n // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar $Object = Object;\nvar ObjectPrototype = $Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n// eslint-disable-next-line es/no-object-getprototypeof -- safe\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {\n var object = toObject(O);\n if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n var constructor = object.constructor;\n if (isCallable(constructor) && object instanceof constructor) {\n return constructor.prototype;\n } return object instanceof $Object ? ObjectPrototype : null;\n};\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {\n var TO_STRING_TAG = NAME + ' Iterator';\n IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });\n setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n Iterators[TO_STRING_TAG] = returnThis;\n return IteratorConstructor;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/iterator-create-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n createIteratorConstructor(IteratorConstructor, NAME, next);\n\n var getIterationMethod = function (KIND) {\n if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];\n\n switch (KIND) {\n case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n }\n\n return function () { return new IteratorConstructor(this); };\n };\n\n var TO_STRING_TAG = NAME + ' Iterator';\n var INCORRECT_VALUES_NAME = false;\n var IterablePrototype = Iterable.prototype;\n var nativeIterator = IterablePrototype[ITERATOR]\n || IterablePrototype['@@iterator']\n || DEFAULT && IterablePrototype[DEFAULT];\n var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n var CurrentIteratorPrototype, methods, KEY;\n\n // fix native\n if (anyNativeIterator) {\n CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n if (setPrototypeOf) {\n setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);\n }\n }\n // Set @@toStringTag to native iterators\n setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n }\n }\n\n // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n } else {\n INCORRECT_VALUES_NAME = true;\n defaultIterator = function values() { return call(nativeIterator, this); };\n }\n }\n\n // export additional methods\n if (DEFAULT) {\n methods = {\n values: getIterationMethod(VALUES),\n keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n entries: getIterationMethod(ENTRIES)\n };\n if (FORCED) for (KEY in methods) {\n if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n defineBuiltIn(IterablePrototype, KEY, methods[KEY]);\n }\n } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n }\n\n // define iterator\n if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n }\n Iterators[NAME] = defaultIterator;\n\n return methods;\n};\n","'use strict';\n// `CreateIterResultObject` abstract operation\n// https://tc39.es/ecma262/#sec-createiterresultobject\nmodule.exports = function (value, done) {\n return { value: value, done: done };\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineProperty = require('../internals/object-define-property').f;\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar IS_PURE = require('../internals/is-pure');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n setInternalState(this, {\n type: ARRAY_ITERATOR,\n target: toIndexedObject(iterated), // target\n index: 0, // next index\n kind: kind // kind\n });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n var state = getInternalState(this);\n var target = state.target;\n var index = state.index++;\n if (!target || index >= target.length) {\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n switch (state.kind) {\n case 'keys': return createIterResultObject(index, false);\n case 'values': return createIterResultObject(target[index], false);\n } return createIterResultObject([index, target[index]], false);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nvar values = Iterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n// V8 ~ Chrome 45- bug\nif (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {\n defineProperty(values, 'name', { value: 'values' });\n} catch (error) { /* empty */ }\n","'use strict';\nvar classof = require('../internals/classof');\n\nvar $String = String;\n\nmodule.exports = function (argument) {\n if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n return $String(argument);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n return function ($this, pos) {\n var S = toString(requireObjectCoercible($this));\n var position = toIntegerOrInfinity(pos);\n var size = S.length;\n var first, second;\n if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n first = charCodeAt(S, position);\n return first < 0xD800 || first > 0xDBFF || position + 1 === size\n || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n ? CONVERT_TO_STRING\n ? charAt(S, position)\n : first\n : CONVERT_TO_STRING\n ? stringSlice(S, position, position + 2)\n : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n };\n};\n\nmodule.exports = {\n // `String.prototype.codePointAt` method\n // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n codeAt: createMethod(false),\n // `String.prototype.at` method\n // https://github.com/mathiasbynens/String.prototype.at\n charAt: createMethod(true)\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n setInternalState(this, {\n type: STRING_ITERATOR,\n string: toString(iterated),\n index: 0\n });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n var state = getInternalState(this);\n var string = state.string;\n var index = state.index;\n var point;\n if (index >= string.length) return createIterResultObject(undefined, true);\n point = charAt(string, index);\n state.index += point.length;\n return createIterResultObject(point, false);\n});\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n var propertyKey = toPropertyKey(key);\n if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n else object[propertyKey] = value;\n};\n","'use strict';\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\n\nvar $Array = Array;\nvar max = Math.max;\n\nmodule.exports = function (O, start, end) {\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n var result = $Array(max(fin - k, 0));\n var n = 0;\n for (; k < fin; k++, n++) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n};\n","'use strict';\n/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n try {\n return $getOwnPropertyNames(it);\n } catch (error) {\n return arraySlice(windowNames);\n }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n return windowNames && classof(it) === 'Window'\n ? getWindowNames(it)\n : $getOwnPropertyNames(toIndexedObject(it));\n};\n","'use strict';\n// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it\nvar fails = require('../internals/fails');\n\nmodule.exports = fails(function () {\n if (typeof ArrayBuffer == 'function') {\n var buffer = new ArrayBuffer(8);\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe\n if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar ARRAY_BUFFER_NON_EXTENSIBLE = require('../internals/array-buffer-non-extensible');\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar $isExtensible = Object.isExtensible;\nvar FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); });\n\n// `Object.isExtensible` method\n// https://tc39.es/ecma262/#sec-object.isextensible\nmodule.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) {\n if (!isObject(it)) return false;\n if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false;\n return $isExtensible ? $isExtensible(it) : true;\n} : $isExtensible;\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n return Object.isExtensible(Object.preventExtensions({}));\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar isExtensible = require('../internals/object-is-extensible');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar setMetadata = function (it) {\n defineProperty(it, METADATA, { value: {\n objectID: 'O' + id++, // object ID\n weakData: {} // weak collections IDs\n } });\n};\n\nvar fastKey = function (it, create) {\n // return a primitive with prefix\n if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return 'F';\n // not necessary to add metadata\n if (!create) return 'E';\n // add missing metadata\n setMetadata(it);\n // return object ID\n } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return true;\n // not necessary to add metadata\n if (!create) return false;\n // add missing metadata\n setMetadata(it);\n // return the store of weak collections IDs\n } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n return it;\n};\n\nvar enable = function () {\n meta.enable = function () { /* empty */ };\n REQUIRED = true;\n var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n var splice = uncurryThis([].splice);\n var test = {};\n test[METADATA] = 1;\n\n // prevent exposing of metadata key\n if (getOwnPropertyNames(test).length) {\n getOwnPropertyNamesModule.f = function (it) {\n var result = getOwnPropertyNames(it);\n for (var i = 0, length = result.length; i < length; i++) {\n if (result[i] === METADATA) {\n splice(result, i, 1);\n break;\n }\n } return result;\n };\n\n $({ target: 'Object', stat: true, forced: true }, {\n getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n });\n }\n};\n\nvar meta = module.exports = {\n enable: enable,\n fastKey: fastKey,\n getWeakData: getWeakData,\n onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n var NewTarget, NewTargetPrototype;\n if (\n // it can work only with native `setPrototypeOf`\n setPrototypeOf &&\n // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n isCallable(NewTarget = dummy.constructor) &&\n NewTarget !== Wrapper &&\n isObject(NewTargetPrototype = NewTarget.prototype) &&\n NewTargetPrototype !== Wrapper.prototype\n ) setPrototypeOf($this, NewTargetPrototype);\n return $this;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n var ADDER = IS_MAP ? 'set' : 'add';\n var NativeConstructor = global[CONSTRUCTOR_NAME];\n var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n var Constructor = NativeConstructor;\n var exported = {};\n\n var fixMethod = function (KEY) {\n var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n defineBuiltIn(NativePrototype, KEY,\n KEY === 'add' ? function add(value) {\n uncurriedNativeMethod(this, value === 0 ? 0 : value);\n return this;\n } : KEY === 'delete' ? function (key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'get' ? function get(key) {\n return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'has' ? function has(key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : function set(key, value) {\n uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n return this;\n }\n );\n };\n\n var REPLACE = isForced(\n CONSTRUCTOR_NAME,\n !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n new NativeConstructor().entries().next();\n }))\n );\n\n if (REPLACE) {\n // create collection constructor\n Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n InternalMetadataModule.enable();\n } else if (isForced(CONSTRUCTOR_NAME, true)) {\n var instance = new Constructor();\n // early implementations not supports chaining\n var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance;\n // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n // most early implementations doesn't supports iterables, most modern - not close it correctly\n // eslint-disable-next-line no-new -- required for testing\n var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n // for early implementations -0 and +0 not the same\n var BUGGY_ZERO = !IS_WEAK && fails(function () {\n // V8 ~ Chromium 42- fails only with 5+ elements\n var $instance = new NativeConstructor();\n var index = 5;\n while (index--) $instance[ADDER](index, index);\n return !$instance.has(-0);\n });\n\n if (!ACCEPT_ITERABLES) {\n Constructor = wrapper(function (dummy, iterable) {\n anInstance(dummy, NativePrototype);\n var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n return that;\n });\n Constructor.prototype = NativePrototype;\n NativePrototype.constructor = Constructor;\n }\n\n if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n fixMethod('delete');\n fixMethod('has');\n IS_MAP && fixMethod('get');\n }\n\n if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n // weak collections should not contains .clear method\n if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n }\n\n exported[CONSTRUCTOR_NAME] = Constructor;\n $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported);\n\n setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n return Constructor;\n};\n","'use strict';\nvar defineBuiltIn = require('../internals/define-built-in');\n\nmodule.exports = function (target, src, options) {\n for (var key in src) defineBuiltIn(target, key, src[key], options);\n return target;\n};\n","'use strict';\nvar classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n return classof(argument) === 'Array';\n};\n","'use strict';\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n var C;\n if (isArray(originalArray)) {\n C = originalArray.constructor;\n // cross-realm fallback\n if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;\n else if (isObject(C)) {\n C = C[SPECIES];\n if (C === null) C = undefined;\n }\n } return C === undefined ? $Array : C;\n};\n","'use strict';\nvar arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n var IS_MAP = TYPE === 1;\n var IS_FILTER = TYPE === 2;\n var IS_SOME = TYPE === 3;\n var IS_EVERY = TYPE === 4;\n var IS_FIND_INDEX = TYPE === 6;\n var IS_FILTER_REJECT = TYPE === 7;\n var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;\n return function ($this, callbackfn, that, specificCreate) {\n var O = toObject($this);\n var self = IndexedObject(O);\n var length = lengthOfArrayLike(self);\n var boundFunction = bind(callbackfn, that);\n var index = 0;\n var create = specificCreate || arraySpeciesCreate;\n var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n var value, result;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n value = self[index];\n result = boundFunction(value, index, O);\n if (TYPE) {\n if (IS_MAP) target[index] = result; // map\n else if (result) switch (TYPE) {\n case 3: return true; // some\n case 5: return value; // find\n case 6: return index; // findIndex\n case 2: push(target, value); // filter\n } else switch (TYPE) {\n case 4: return false; // every\n case 7: push(target, value); // filterReject\n }\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.forEach` method\n // https://tc39.es/ecma262/#sec-array.prototype.foreach\n forEach: createMethod(0),\n // `Array.prototype.map` method\n // https://tc39.es/ecma262/#sec-array.prototype.map\n map: createMethod(1),\n // `Array.prototype.filter` method\n // https://tc39.es/ecma262/#sec-array.prototype.filter\n filter: createMethod(2),\n // `Array.prototype.some` method\n // https://tc39.es/ecma262/#sec-array.prototype.some\n some: createMethod(3),\n // `Array.prototype.every` method\n // https://tc39.es/ecma262/#sec-array.prototype.every\n every: createMethod(4),\n // `Array.prototype.find` method\n // https://tc39.es/ecma262/#sec-array.prototype.find\n find: createMethod(5),\n // `Array.prototype.findIndex` method\n // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n findIndex: createMethod(6),\n // `Array.prototype.filterReject` method\n // https://github.com/tc39/proposal-array-filtering\n filterReject: createMethod(7)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar getWeakData = require('../internals/internal-metadata').getWeakData;\nvar anInstance = require('../internals/an-instance');\nvar anObject = require('../internals/an-object');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar iterate = require('../internals/iterate');\nvar ArrayIterationModule = require('../internals/array-iteration');\nvar hasOwn = require('../internals/has-own-property');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\nvar find = ArrayIterationModule.find;\nvar findIndex = ArrayIterationModule.findIndex;\nvar splice = uncurryThis([].splice);\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (state) {\n return state.frozen || (state.frozen = new UncaughtFrozenStore());\n};\n\nvar UncaughtFrozenStore = function () {\n this.entries = [];\n};\n\nvar findUncaughtFrozen = function (store, key) {\n return find(store.entries, function (it) {\n return it[0] === key;\n });\n};\n\nUncaughtFrozenStore.prototype = {\n get: function (key) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) return entry[1];\n },\n has: function (key) {\n return !!findUncaughtFrozen(this, key);\n },\n set: function (key, value) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) entry[1] = value;\n else this.entries.push([key, value]);\n },\n 'delete': function (key) {\n var index = findIndex(this.entries, function (it) {\n return it[0] === key;\n });\n if (~index) splice(this.entries, index, 1);\n return !!~index;\n }\n};\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n id: id++,\n frozen: undefined\n });\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var data = getWeakData(anObject(key), true);\n if (data === true) uncaughtFrozenStore(state).set(key, value);\n else data[state.id] = value;\n return that;\n };\n\n defineBuiltIns(Prototype, {\n // `{ WeakMap, WeakSet }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.delete\n // https://tc39.es/ecma262/#sec-weakset.prototype.delete\n 'delete': function (key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state)['delete'](key);\n return data && hasOwn(data, state.id) && delete data[state.id];\n },\n // `{ WeakMap, WeakSet }.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.has\n // https://tc39.es/ecma262/#sec-weakset.prototype.has\n has: function has(key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).has(key);\n return data && hasOwn(data, state.id);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `WeakMap.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.get\n get: function get(key) {\n var state = getInternalState(this);\n if (isObject(key)) {\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).get(key);\n return data ? data[state.id] : undefined;\n }\n },\n // `WeakMap.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.set\n set: function set(key, value) {\n return define(this, key, value);\n }\n } : {\n // `WeakSet.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-weakset.prototype.add\n add: function add(value) {\n return define(this, value, true);\n }\n });\n\n return Constructor;\n }\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionWeak = require('../internals/collection-weak');\n\n// `WeakSet` constructor\n// https://tc39.es/ecma262/#sec-weakset-constructor\ncollection('WeakSet', function (init) {\n return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionWeak);\n","'use strict';\n// iterable DOM collections\n// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods\nmodule.exports = {\n CSSRuleList: 0,\n CSSStyleDeclaration: 0,\n CSSValueList: 0,\n ClientRectList: 0,\n DOMRectList: 0,\n DOMStringList: 0,\n DOMTokenList: 1,\n DataTransferItemList: 0,\n FileList: 0,\n HTMLAllCollection: 0,\n HTMLCollection: 0,\n HTMLFormElement: 0,\n HTMLSelectElement: 0,\n MediaList: 0,\n MimeTypeArray: 0,\n NamedNodeMap: 0,\n NodeList: 1,\n PaintRequestList: 0,\n Plugin: 0,\n PluginArray: 0,\n SVGLengthList: 0,\n SVGNumberList: 0,\n SVGPathSegList: 0,\n SVGPointList: 0,\n SVGStringList: 0,\n SVGTransformList: 0,\n SourceBufferList: 0,\n StyleSheetList: 0,\n TextTrackCueList: 0,\n TextTrackList: 0,\n TouchList: 0\n};\n","'use strict';\n// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`\nvar documentCreateElement = require('../internals/document-create-element');\n\nvar classList = documentCreateElement('span').classList;\nvar DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;\n\nmodule.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nvar handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {\n if (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n } catch (error) {\n CollectionPrototype[ITERATOR] = ArrayValues;\n }\n setToStringTag(CollectionPrototype, COLLECTION_NAME, true);\n if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n } catch (error) {\n CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n }\n }\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);\n}\n\nhandlePrototype(DOMTokenListPrototype, 'DOMTokenList');\n","'use strict';\nvar $forEach = require('../internals/array-iteration').forEach;\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar STRICT_METHOD = arrayMethodIsStrict('forEach');\n\n// `Array.prototype.forEach` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.foreach\nmodule.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {\n return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n// eslint-disable-next-line es/no-array-prototype-foreach -- safe\n} : [].forEach;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar forEach = require('../internals/array-for-each');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar handlePrototype = function (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {\n createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);\n } catch (error) {\n CollectionPrototype.forEach = forEach;\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n if (DOMIterables[COLLECTION_NAME]) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype);\n }\n}\n\nhandlePrototype(DOMTokenListPrototype);\n","'use strict';\nvar $ = require('../internals/export');\nvar toObject = require('../internals/to-object');\nvar nativeKeys = require('../internals/object-keys');\nvar fails = require('../internals/fails');\n\nvar FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {\n keys: function keys(it) {\n return nativeKeys(toObject(it));\n }\n});\n","export enum ScrollDirection {\n SCROLL_NONE,\n SCROLL_BACKWARD,\n SCROLL_FORWARD,\n}\n\nexport enum Position {\n TOP,\n RIGHT,\n BOTTOM,\n LEFT,\n}\n\nexport const OPTIONS_DEFAULT_DOMAIN_TYPE = 'hour';\n\nexport const OPTIONS_DEFAULT_SUBDOMAIN_TYPE = 'minute';\nexport const OPTIONS_DEFAULT_SUBDOMAIN_WIDTH = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_GUTTER = 2;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_RADIUS = 0;\nexport const OPTIONS_DEFAULT_ANIMATION_DURATION = 200;\nexport const OPTIONS_DEFAULT_RANGE = 12;\nexport const OPTIONS_DEFAULT_ITEM_SELECTOR = '#cal-heatmap';\nexport const OPTIONS_DEFAULT_THEME = 'light';\nexport const OPTIONS_DEFAULT_LOCALE = 'en';\n\nexport const SCALE_BASE_OPACITY_COLOR = 'red';\nexport const SCALE_BASE_COLOR_SCHEME = 'YlOrBr';\nexport const SCALE_BASE_COLOR_TYPE = 'quantize';\nexport const SCALE_BASE_COLOR_DOMAIN = [0, 100];\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n var _, done = false;\r\n for (var i = decorators.length - 1; i >= 0; i--) {\r\n var context = {};\r\n for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n if (kind === \"accessor\") {\r\n if (result === void 0) continue;\r\n if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n if (_ = accept(result.get)) descriptor.get = _;\r\n if (_ = accept(result.set)) descriptor.set = _;\r\n if (_ = accept(result.init)) initializers.unshift(_);\r\n }\r\n else if (_ = accept(result)) {\r\n if (kind === \"field\") initializers.unshift(_);\r\n else descriptor[key] = _;\r\n }\r\n }\r\n if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n var useValue = arguments.length > 2;\r\n for (var i = 0; i < initializers.length; i++) {\r\n value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n }\r\n return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n 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;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n var desc = Object.getOwnPropertyDescriptor(m, k);\r\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n desc = { enumerable: true, get: function() { return m[k]; } };\r\n }\r\n Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport default {\r\n __extends,\r\n __assign,\r\n __rest,\r\n __decorate,\r\n __param,\r\n __metadata,\r\n __awaiter,\r\n __generator,\r\n __createBinding,\r\n __exportStar,\r\n __values,\r\n __read,\r\n __spread,\r\n __spreadArrays,\r\n __spreadArray,\r\n __await,\r\n __asyncGenerator,\r\n __asyncDelegator,\r\n __asyncValues,\r\n __makeTemplateObject,\r\n __importStar,\r\n __importDefault,\r\n __classPrivateFieldGet,\r\n __classPrivateFieldSet,\r\n __classPrivateFieldIn,\r\n};\r\n","import { Position } from '../constant';\nimport type { Padding } from '../options/Options';\n\nexport function isHorizontal(position: string): boolean {\n return position === 'left' || position === 'right';\n}\n\nexport function isVertical(position: string): boolean {\n return position === 'top' || position === 'bottom';\n}\n\nexport function horizontalPadding(padding: Padding): number {\n return padding[Position.LEFT] + padding[Position.RIGHT];\n}\n\nexport function verticalPadding(padding: Padding): number {\n return padding[Position.TOP] + padding[Position.BOTTOM];\n}\n","import { Position } from '../constant';\nimport {\n isHorizontal,\n isVertical,\n horizontalPadding,\n verticalPadding,\n} from '../helpers/PositionHelper';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { IPlugin, PluginOptions } from '../index';\nimport type { TextAlign, Padding } from '../options/Options';\n\ntype ComputedOptions = {\n radius: number;\n width: number;\n height: number;\n gutter: number;\n textAlign: TextAlign;\n};\n\ninterface CalendarLabelOptions extends PluginOptions, Partial {\n enabled: boolean;\n text: () => string[];\n padding: Padding;\n}\n\nconst DEFAULT_SELECTOR = '.ch-plugin-calendar-label';\n\nconst defaultOptions: CalendarLabelOptions = {\n enabled: true,\n\n dimensions: {\n width: 0,\n height: 0,\n },\n\n position: 'left',\n\n text: () => [],\n\n padding: [0, 0, 0, 0],\n};\n\nexport default class CalendarLabel implements IPlugin {\n name = 'CalendarLabel';\n\n calendar: CalHeatmap;\n\n root: any;\n\n shown: boolean;\n\n options: CalendarLabelOptions;\n\n computedOptions: ComputedOptions;\n\n constructor(calendar: CalHeatmap) {\n const subDomain = calendar?.options?.options?.subDomain;\n\n this.calendar = calendar;\n this.root = null;\n this.shown = false;\n this.options = defaultOptions;\n this.computedOptions = {\n radius: subDomain?.radius,\n width: subDomain?.width,\n height: subDomain?.height,\n gutter: subDomain?.gutter,\n textAlign: 'start',\n };\n }\n\n setup(pluginOptions?: Partial): void {\n this.options = { ...defaultOptions, ...pluginOptions };\n }\n\n paint(): Promise {\n const { enabled } = this.options;\n\n if (!enabled) {\n return this.destroy();\n }\n\n this.shown = true;\n\n const calendarRoot = this.calendar.calendarPainter.root;\n\n if (!this.root) {\n this.root = calendarRoot\n .append('svg')\n .attr('class', DEFAULT_SELECTOR.slice(1))\n .attr('data-key', this.options.key)\n .attr('x', 0)\n .attr('y', 0);\n }\n\n this.build();\n\n return Promise.resolve();\n }\n\n destroy(): Promise {\n if (this.root !== null) {\n this.root.remove();\n this.root = null;\n }\n\n return Promise.resolve();\n }\n\n build() {\n this.#buildComputedOptions();\n this.#computeDimensions();\n\n this.root\n .selectAll('g')\n .data(this.options.text)\n .join((enter: any) => enter\n .append('g')\n .call((selection: any) => selection\n .append('rect')\n .attr('class', `${DEFAULT_SELECTOR.slice(1)}-bg`)\n .attr('style', 'fill: transparent')\n .call((s: any) => this.#setRectAttr(s)))\n .call((selection: any) => selection\n .append('text')\n .attr('class', `${DEFAULT_SELECTOR.slice(1)}-text`)\n .attr('dominant-baseline', 'central')\n .attr('text-anchor', 'middle')\n .attr('style', 'fill: currentColor; font-size: 10px')\n .call((s: any) => this.#setTextAttr(s))));\n\n return Promise.resolve();\n }\n\n #buildComputedOptions() {\n Object.keys(this.computedOptions).forEach((key: string) => {\n if (typeof this.options[key as keyof ComputedOptions] !== 'undefined') {\n // @ts-ignore\n this.computedOptions[key] = this.options[key];\n }\n });\n }\n\n /**\n * Compute the total dimension of the current plugin\n */\n #computeDimensions(): void {\n const { width, height, gutter } = this.computedOptions;\n const { text, padding, position } = this.options;\n const labelsCount = text().length;\n\n this.options.dimensions = {\n width: width + horizontalPadding(padding),\n height: height + verticalPadding(padding),\n };\n\n if (isVertical(position!)) {\n this.options.dimensions.width += (width + gutter) * (labelsCount - 1);\n } else {\n this.options.dimensions.height += (height + gutter) * (labelsCount - 1);\n }\n }\n\n #setRectAttr(selection: any) {\n const { width, height, radius } = this.computedOptions;\n\n selection\n .attr('width', width)\n .attr('height', height)\n .attr('rx', radius && radius > 0 ? radius : null)\n .attr('ry', radius && radius > 0 ? radius : null)\n .attr('x', (_d: string, i: number) => this.#getX(i))\n .attr('y', (_d: string, i: number) => this.#getY(i));\n }\n\n #setTextAttr(selection: any): void {\n const { height, textAlign } = this.computedOptions;\n\n selection\n .attr('text-anchor', textAlign)\n .attr(\n 'x',\n (_d: string, i: number) => this.#getTextXOffset() + this.#getX(i),\n )\n .attr('y', (_d: string, i: number) => this.#getY(i) + height! / 2)\n .text((data: string) => data);\n }\n\n #getTextXOffset() {\n const { width, textAlign } = this.computedOptions;\n\n switch (textAlign) {\n case 'start':\n return 0;\n case 'middle':\n return width / 2;\n case 'end':\n return width;\n default:\n return 0;\n }\n }\n\n #getX(index: number) {\n const { position, padding } = this.options;\n const { width, gutter } = this.computedOptions;\n\n if (isHorizontal(position!)) {\n return padding[Position.LEFT];\n }\n\n return padding[Position.LEFT] + (width + gutter) * index;\n }\n\n #getY(index: number) {\n const { position, padding } = this.options;\n const { height, gutter } = this.computedOptions;\n\n if (isVertical(position!)) {\n return padding[Position.TOP];\n }\n\n return padding[Position.TOP] + (height + gutter) * index;\n }\n}\n"],"names":["fails","exec","error","descriptors","require$$0","Object","defineProperty","get","functionBindNative","test","bind","hasOwnProperty","NATIVE_BIND","FunctionPrototype","Function","prototype","call","uncurryThisWithBind","functionUncurryThis","fn","apply","arguments","isNullOrUndefined","it","$TypeError","TypeError","requireObjectCoercible","$Object","toObject","argument","require$$1","hasOwnProperty_1","hasOwn","key","DESCRIPTORS","getDescriptor","getOwnPropertyDescriptor","EXISTS","functionName","PROPER","name","CONFIGURABLE","configurable","makeBuiltIn$3","exports","documentAll","document","all","documentAll_1","IS_HTMLDDA","undefined","isCallable","check","Math","global","globalThis","window","self","this","defineGlobalProperty","value","writable","SHARED","sharedStore","store","require$$2","functionToString","toString","inspectSource","match","version","WeakMap","weakMapBasicDetection","String","isObject","objectDefineProperty","createElement","documentCreateElement","ie8DomDefine","a","v8PrototypeDefineBug","$String","anObject","functionCall","getBuiltIn","namespace","method","length","objectIsPrototypeOf","isPrototypeOf","engineUserAgent","navigator","userAgent","process","Deno","versions","v8","split","engineV8Version","V8_VERSION","symbolConstructorDetection","getOwnPropertySymbols","symbol","Symbol","sham","useSymbolAsUid","iterator","isSymbol","require$$3","$Symbol","tryToString","aCallable","getMethod","V","P","func","shared$3","sharedModule","push","mode","copyright","license","source","uncurryThis","id","postfix","random","uid","shared","NATIVE_SYMBOL","require$$4","USE_SYMBOL_AS_UID","require$$5","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","wellKnownSymbol","ordinaryToPrimitive","input","pref","val","valueOf","TO_PRIMITIVE","toPrimitive","result","exoticToPrim","toPropertyKey","IE8_DOM_DEFINE","V8_PROTOTYPE_DEFINE_BUG","$defineProperty","$getOwnPropertyDescriptor","ENUMERABLE","WRITABLE","f","O","Attributes","current","enumerable","set","has","createPropertyDescriptor","bitmap","definePropertyModule","createNonEnumerableProperty","object","keys","sharedKey","hiddenKeys","NATIVE_WEAK_MAP","require$$6","require$$7","OBJECT_ALREADY_INITIALIZED","state","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","CONFIGURABLE_FUNCTION_NAME","enforceInternalState","getInternalState","stringSlice","slice","replace","join","CONFIGURABLE_LENGTH","TEMPLATE","makeBuiltIn","makeBuiltInModule","options","getter","setter","arity","constructor","defineBuiltInAccessor","target","descriptor","FUNCTION_NAME_EXISTS","nameRE","regExpExec","objectGetOwnPropertyDescriptor","objectPropertyIsEnumerable","$propertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","classofRaw","classof","indexedObject","IndexedObject","toIndexedObject","propertyIsEnumerableModule","defineBuiltIn","simple","unsafe","nonConfigurable","nonWritable","ceil","floor","trunc","x","n","toIntegerOrInfinity","number","max","min","toAbsoluteIndex","index","integer","toLength","lengthOfArrayLike","obj","createMethod","IS_INCLUDES","$this","el","fromIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","i","enumBugKeys","internalObjectKeys","concat","objectGetOwnPropertyNames","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","ownKeys","getOwnPropertyDescriptorModule","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","toLowerCase","isForced_1","copyConstructorProperties","exceptions","_export","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","objectKeys","require$$8","$assign","assign","objectAssign","b","A","B","alphabet","forEach","chr","T","argumentsLength","S","j","toStringTagSupport","TO_STRING_TAG_SUPPORT","TO_STRING_TAG","CORRECT_ARGUMENTS","tag","tryGet","callee","engineIsNode","uncurryThisAccessor","aPossiblePrototype","objectSetPrototypeOf","setPrototypeOf","CORRECT_SETTER","Array","proto","__proto__","setToStringTag","TAG","SPECIES","anInstance","Prototype","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","$location","defer","channel","port","isConstructor","called","aConstructor","functionApply","Reflect","functionBindContext","that","html","arraySlice","engineIsIos","validateArgumentsLength","passed","required","IS_IOS","require$$10","IS_NODE","require$$11","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","location","run","runner","eventListener","event","globalPostMessageDefer","postMessage","protocol","host","handler","args","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","task","Queue","head","tail","add","item","entry","next","notify","toggle","node","promise","then","engineIsIosPebble","Pebble","engineIsWebosWebkit","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","Promise","queueMicrotaskDescriptor","microtask","flush","parent","domain","exit","enter","resolve","createTextNode","observe","characterData","microtask_1","perform","promiseNativeConstructor","engineIsDeno","engineIsBrowser","NativePromiseConstructor","IS_BROWSER","IS_DENO","require$$9","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","promiseConstructorDetection","CONSTRUCTOR","REJECTION_EVENT","newPromiseCapability$2","PromiseCapability","C","reject","$$resolve","$$reject","newPromiseCapability","Internal","OwnPromiseCapability","nativeThen","$","setSpecies","CONSTRUCTOR_NAME","Constructor","require$$12","speciesConstructor","defaultConstructor","require$$14","require$$15","hostReportErrors","console","require$$17","require$$18","InternalStateModule","require$$19","require$$20","newPromiseCapabilityModule","require$$22","PROMISE","require$$21","NATIVE_PROMISE_SUBCLASSING","getInternalPromiseState","setInternalState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","isThenable","callReaction","reaction","exited","ok","fail","rejection","onHandleUnhandled","isReject","notified","reactions","onUnhandled","reason","initEvent","isUnhandled","emit","unwrap","internalReject","done","internalResolve","wrapper","executor","onFulfilled","onRejected","PromiseWrapper","wrap","iterators","Iterators","ITERATOR","ArrayPrototype","getIteratorMethod","isArrayIteratorMethod","getIterator","usingIterator","iteratorMethod","iteratorClose","kind","innerResult","innerError","Result","stopped","ResultPrototype","iterate","iterable","unboundFunction","iterFn","step","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","SAFE_CLOSING","iteratorWithReturn","return","from","checkCorrectnessOfIteration","SKIP_CLOSING","ITERATION_SUPPORT","promiseStaticsIncorrectIteration","capability","$promiseResolve","values","remaining","alreadyCalled","real","catch","race","r","promiseResolve","promiseCapability","arrayMethodIsStrict","METHOD_NAME","nativeJoin","separator","objectDefineProperties","defineProperties","Properties","props","activeXDocument","definePropertiesModule","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","style","display","src","contentWindow","open","F","objectCreate","create","UNSCOPABLES","IteratorPrototype","PrototypeOfArrayIteratorPrototype","arrayIterator","correctPrototypeGetter","getPrototypeOf","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","objectGetPrototypeOf","BUGGY_SAFARI_ITERATORS","NEW_ITERATOR_PROTOTYPE","iteratorsCore","returnThis","createIteratorConstructor","IteratorConstructor","NAME","ENUMERABLE_NEXT","PROPER_FUNCTION_NAME","require$$13","KEYS","VALUES","ENTRIES","iteratorDefine","Iterable","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","createIterResultObject","addToUnscopables","defineIterator","ARRAY_ITERATOR","es_array_iterator","iterated","Arguments","charAt","charCodeAt","CONVERT_TO_STRING","pos","first","second","position","size","codeAt","STRING_ITERATOR","point","internalMetadata","objectGetOwnPropertyNamesExternal","createProperty","propertyKey","$Array","$getOwnPropertyNames","start","end","k","fin","windowNames","getWindowNames","arrayBufferNonExtensible","ArrayBuffer","buffer","isExtensible","ARRAY_BUFFER_NON_EXTENSIBLE","$isExtensible","objectIsExtensible","freezing","preventExtensions","getOwnPropertyNamesExternalModule","FREEZING","REQUIRED","METADATA","setMetadata","objectID","weakData","meta","internalMetadataModule","enable","splice","fastKey","getWeakData","onFreeze","InternalMetadataModule","inheritIfRequired","dummy","Wrapper","NewTarget","NewTargetPrototype","isArray","arraySpeciesConstructor","originalArray","arraySpeciesCreate","IS_MAP","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_REJECT","NO_HOLES","callbackfn","specificCreate","boundFunction","arrayIteration","map","filter","some","every","find","findIndex","filterReject","defineBuiltIns","internalStateGetterFor","uncaughtFrozenStore","frozen","UncaughtFrozenStore","findUncaughtFrozen","delete","collectionWeak","getConstructor","ADDER","define","common","IS_WEAK","NativeConstructor","NativePrototype","exported","fixMethod","uncurriedNativeMethod","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","setStrong","collection","init","domIterables","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DOMTokenList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","classList","DOMTokenListPrototype","domTokenListPrototype","DOMIterables","ArrayIteratorMethods","ArrayValues","handlePrototype","CollectionPrototype","COLLECTION_NAME","$forEach","arrayForEach","ScrollDirection","Position","nativeKeys","__classPrivateFieldGet","receiver","isVertical","horizontalPadding","padding","LEFT","RIGHT","verticalPadding","TOP","BOTTOM","DEFAULT_SELECTOR","defaultOptions","enabled","dimensions","width","height","text","CalendarLabel","calendar","_classCallCheck","subDomain","_b","_a","root","shown","computedOptions","radius","gutter","textAlign","pluginOptions","destroy","calendarRoot","calendarPainter","append","attr","build","remove","_this","_CalendarLabel_instances","_CalendarLabel_buildComputedOptions","_CalendarLabel_computeDimensions","selectAll","selection","s","_CalendarLabel_setRectAttr","_CalendarLabel_setTextAttr","_this2","_this$computedOptions","_this$options","labelsCount","_this3","_this$computedOptions2","_d","_CalendarLabel_getX","_this4","_this$computedOptions3","_CalendarLabel_getY","_CalendarLabel_getTextXOffset","_this$computedOptions4","_this$options2","_this$computedOptions5","isHorizontal","_this$options3","_this$computedOptions6"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,156]} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Legend.esm.js b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.esm.js new file mode 100644 index 0000000..1d2e119 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.esm.js @@ -0,0 +1,4521 @@ +import { select as select$1 } from 'd3-selection'; +import { ascending, timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear, timeMonday, timeTuesday, timeWednesday, timeThursday, timeFriday, timeSaturday, timeSunday, utcSecond, utcMinute, utcHour, utcDay, utcWeek, utcMonth, utcYear, utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSunday, color as color$1, descending, range, symbolAsterisk, symbolCircle, symbolCross, symbolDiamond, symbolDiamond2, symbolPlus, symbolSquare, symbolSquare2, symbolStar, symbolTimes, symbolTriangle, symbolTriangle2, symbolWye, geoPath, geoTransform, geoClipRectangle, geoTransverseMercator, geoStereographic, geoOrthographic, geoMercator, geoGnomonic, geoEquirectangular, geoEqualEarth, geoAzimuthalEquidistant, geoAzimuthalEqualArea, geoAlbersUsa, geoConicEquidistant, geoConicEqualArea, geoConicConformal, geoAlbers, select, creator, schemeAccent, schemeCategory10, schemeDark2, schemePaired, schemePastel1, schemePastel2, schemeSet1, schemeSet2, schemeSet3, schemeTableau10, quantize, interpolateBrBG, interpolatePRGn, interpolatePiYG, interpolatePuOr, interpolateRdBu, interpolateRdGy, interpolateRdYlBu, interpolateRdYlGn, interpolateSpectral, interpolateBlues, interpolateGreens, interpolateGreys, interpolatePurples, interpolateReds, interpolateOranges, interpolateTurbo, interpolateViridis, interpolateMagma, interpolateInferno, interpolatePlasma, interpolateCividis, interpolateCubehelixDefault, interpolateWarm, interpolateCool, interpolateBuGn, interpolateBuPu, interpolateGnBu, interpolateOrRd, interpolatePuBuGn, interpolatePuBu, interpolatePuRd, interpolateRdPu, interpolateYlGnBu, interpolateYlGn, interpolateYlOrBr, interpolateYlOrRd, interpolateRainbow, interpolateSinebow, schemeBrBG, schemePRGn, schemePiYG, schemePuOr, schemeRdBu, schemeRdGy, schemeRdYlBu, schemeRdYlGn, schemeSpectral, schemeBlues, schemeGreens, schemeGreys, schemeOranges, schemePurples, schemeReds, schemeBuGn, schemeBuPu, schemeGnBu, schemeOrRd, schemePuBu, schemePuBuGn, schemePuRd, schemeRdPu, schemeYlGn, schemeYlGnBu, schemeYlOrBr, schemeYlOrRd, scaleLinear, scalePow, scaleLog, scaleSymlog, scaleQuantile, extent, ticks, interpolateNumber, reverse, scaleThreshold, scaleIdentity, max as max$1, interpolateRgb, interpolateRound, min as min$2, quantile, median, interpolateHsl, interpolateHcl, interpolateLab, scaleDiverging, scaleDivergingPow, scaleDivergingLog, scaleDivergingSymlog, piecewise, scaleTime, scaleUtc, scaleImplicit, scaleOrdinal, scalePoint, scaleBand, InternSet, sort, symbolsStroke, symbolsFill, utcFormat, format as format$1, axisBottom, pathRound, rgb } from 'd3'; + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } +} +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; +} +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); +} +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); +} + +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +var fails$b = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + +var fails$a = fails$b; + +// Detect IE8's incomplete defineProperty implementation +var descriptors = !fails$a(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; +}); + +var fails$9 = fails$b; + +var functionBindNative = !fails$9(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); +}); + +var NATIVE_BIND$3 = functionBindNative; + +var FunctionPrototype$3 = Function.prototype; +var call$d = FunctionPrototype$3.call; +var uncurryThisWithBind = NATIVE_BIND$3 && FunctionPrototype$3.bind.bind(call$d, call$d); + +var functionUncurryThis = NATIVE_BIND$3 ? uncurryThisWithBind : function (fn) { + return function () { + return call$d.apply(fn, arguments); + }; +}; + +// we can't use just `it == null` since of `document.all` special case +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec +var isNullOrUndefined$4 = function (it) { + return it === null || it === undefined; +}; + +var isNullOrUndefined$3 = isNullOrUndefined$4; + +var $TypeError$c = TypeError; + +// `RequireObjectCoercible` abstract operation +// https://tc39.es/ecma262/#sec-requireobjectcoercible +var requireObjectCoercible$2 = function (it) { + if (isNullOrUndefined$3(it)) throw new $TypeError$c("Can't call method on " + it); + return it; +}; + +var requireObjectCoercible$1 = requireObjectCoercible$2; + +var $Object$3 = Object; + +// `ToObject` abstract operation +// https://tc39.es/ecma262/#sec-toobject +var toObject$2 = function (argument) { + return $Object$3(requireObjectCoercible$1(argument)); +}; + +var uncurryThis$f = functionUncurryThis; +var toObject$1 = toObject$2; + +var hasOwnProperty = uncurryThis$f({}.hasOwnProperty); + +// `HasOwnProperty` abstract operation +// https://tc39.es/ecma262/#sec-hasownproperty +// eslint-disable-next-line es/no-object-hasown -- safe +var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject$1(it), key); +}; + +var DESCRIPTORS$9 = descriptors; +var hasOwn$8 = hasOwnProperty_1; + +var FunctionPrototype$2 = Function.prototype; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getDescriptor = DESCRIPTORS$9 && Object.getOwnPropertyDescriptor; + +var EXISTS$1 = hasOwn$8(FunctionPrototype$2, 'name'); +// additional protection from minified / mangled / dropped function names +var PROPER = EXISTS$1 && (function something() { /* empty */ }).name === 'something'; +var CONFIGURABLE$1 = EXISTS$1 && (!DESCRIPTORS$9 || (DESCRIPTORS$9 && getDescriptor(FunctionPrototype$2, 'name').configurable)); + +var functionName = { + EXISTS: EXISTS$1, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE$1 +}; + +var makeBuiltIn$3 = {exports: {}}; + +var documentAll$2 = typeof document == 'object' && document.all; + +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot +// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing +var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined; + +var documentAll_1 = { + all: documentAll$2, + IS_HTMLDDA: IS_HTMLDDA +}; + +var $documentAll$1 = documentAll_1; + +var documentAll$1 = $documentAll$1.all; + +// `IsCallable` abstract operation +// https://tc39.es/ecma262/#sec-iscallable +var isCallable$h = $documentAll$1.IS_HTMLDDA ? function (argument) { + return typeof argument == 'function' || argument === documentAll$1; +} : function (argument) { + return typeof argument == 'function'; +}; + +var check = function (it) { + return it && it.Math === Math && it; +}; + +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +var global$h = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + +var global$g = global$h; + +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty$4 = Object.defineProperty; + +var defineGlobalProperty$3 = function (key, value) { + try { + defineProperty$4(global$g, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$g[key] = value; + } return value; +}; + +var global$f = global$h; +var defineGlobalProperty$2 = defineGlobalProperty$3; + +var SHARED = '__core-js_shared__'; +var store$3 = global$f[SHARED] || defineGlobalProperty$2(SHARED, {}); + +var sharedStore = store$3; + +var uncurryThis$e = functionUncurryThis; +var isCallable$g = isCallable$h; +var store$2 = sharedStore; + +var functionToString$1 = uncurryThis$e(Function.toString); + +// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper +if (!isCallable$g(store$2.inspectSource)) { + store$2.inspectSource = function (it) { + return functionToString$1(it); + }; +} + +var inspectSource$3 = store$2.inspectSource; + +var global$e = global$h; +var isCallable$f = isCallable$h; + +var WeakMap$1 = global$e.WeakMap; + +var weakMapBasicDetection = isCallable$f(WeakMap$1) && /native code/.test(String(WeakMap$1)); + +var isCallable$e = isCallable$h; +var $documentAll = documentAll_1; + +var documentAll = $documentAll.all; + +var isObject$8 = $documentAll.IS_HTMLDDA ? function (it) { + return typeof it == 'object' ? it !== null : isCallable$e(it) || it === documentAll; +} : function (it) { + return typeof it == 'object' ? it !== null : isCallable$e(it); +}; + +var objectDefineProperty = {}; + +var global$d = global$h; +var isObject$7 = isObject$8; + +var document$3 = global$d.document; +// typeof document.createElement is 'object' in old IE +var EXISTS = isObject$7(document$3) && isObject$7(document$3.createElement); + +var documentCreateElement = function (it) { + return EXISTS ? document$3.createElement(it) : {}; +}; + +var DESCRIPTORS$8 = descriptors; +var fails$8 = fails$b; +var createElement$1 = documentCreateElement; + +// Thanks to IE8 for its funny defineProperty +var ie8DomDefine = !DESCRIPTORS$8 && !fails$8(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { + get: function () { return 7; } + }).a !== 7; +}); + +var DESCRIPTORS$7 = descriptors; +var fails$7 = fails$b; + +// V8 ~ Chrome 36- +// https://bugs.chromium.org/p/v8/issues/detail?id=3334 +var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$7(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; +}); + +var isObject$6 = isObject$8; + +var $String$4 = String; +var $TypeError$b = TypeError; + +// `Assert: Type(argument) is Object` +var anObject$8 = function (argument) { + if (isObject$6(argument)) return argument; + throw new $TypeError$b($String$4(argument) + ' is not an object'); +}; + +var NATIVE_BIND$2 = functionBindNative; + +var call$c = Function.prototype.call; + +var functionCall = NATIVE_BIND$2 ? call$c.bind(call$c) : function () { + return call$c.apply(call$c, arguments); +}; + +var global$c = global$h; +var isCallable$d = isCallable$h; + +var aFunction = function (argument) { + return isCallable$d(argument) ? argument : undefined; +}; + +var getBuiltIn$7 = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$c[namespace]) : global$c[namespace] && global$c[namespace][method]; +}; + +var uncurryThis$d = functionUncurryThis; + +var objectIsPrototypeOf = uncurryThis$d({}.isPrototypeOf); + +var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || ''; + +var global$b = global$h; +var userAgent$3 = engineUserAgent; + +var process$3 = global$b.process; +var Deno$1 = global$b.Deno; +var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version; +var v8 = versions && versions.v8; +var match, version; + +if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); +} + +// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` +// so check `userAgent` even if `.v8` exists, but 0 +if (!version && userAgent$3) { + match = userAgent$3.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$3.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } +} + +var engineV8Version = version; + +/* eslint-disable es/no-symbol -- required for testing */ +var V8_VERSION$1 = engineV8Version; +var fails$6 = fails$b; +var global$a = global$h; + +var $String$3 = global$a.String; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing +var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$6(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String$3(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$1 && V8_VERSION$1 < 41; +}); + +/* eslint-disable es/no-symbol -- required for testing */ +var NATIVE_SYMBOL$1 = symbolConstructorDetection; + +var useSymbolAsUid = NATIVE_SYMBOL$1 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + +var getBuiltIn$6 = getBuiltIn$7; +var isCallable$c = isCallable$h; +var isPrototypeOf$2 = objectIsPrototypeOf; +var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + +var $Object$2 = Object; + +var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + var $Symbol = getBuiltIn$6('Symbol'); + return isCallable$c($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$2(it)); +}; + +var $String$2 = String; + +var tryToString$4 = function (argument) { + try { + return $String$2(argument); + } catch (error) { + return 'Object'; + } +}; + +var isCallable$b = isCallable$h; +var tryToString$3 = tryToString$4; + +var $TypeError$a = TypeError; + +// `Assert: IsCallable(argument) is true` +var aCallable$8 = function (argument) { + if (isCallable$b(argument)) return argument; + throw new $TypeError$a(tryToString$3(argument) + ' is not a function'); +}; + +var aCallable$7 = aCallable$8; +var isNullOrUndefined$2 = isNullOrUndefined$4; + +// `GetMethod` abstract operation +// https://tc39.es/ecma262/#sec-getmethod +var getMethod$3 = function (V, P) { + var func = V[P]; + return isNullOrUndefined$2(func) ? undefined : aCallable$7(func); +}; + +var call$b = functionCall; +var isCallable$a = isCallable$h; +var isObject$5 = isObject$8; + +var $TypeError$9 = TypeError; + +// `OrdinaryToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-ordinarytoprimitive +var ordinaryToPrimitive$1 = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable$a(fn = input.toString) && !isObject$5(val = call$b(fn, input))) return val; + if (isCallable$a(fn = input.valueOf) && !isObject$5(val = call$b(fn, input))) return val; + if (pref !== 'string' && isCallable$a(fn = input.toString) && !isObject$5(val = call$b(fn, input))) return val; + throw new $TypeError$9("Can't convert object to primitive value"); +}; + +var shared$3 = {exports: {}}; + +var store$1 = sharedStore; + +(shared$3.exports = function (key, value) { + return store$1[key] || (store$1[key] = value !== undefined ? value : {}); +})('versions', []).push({ + version: '3.34.0', + mode: 'global', + copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE', + source: 'https://github.com/zloirock/core-js' +}); + +var sharedExports = shared$3.exports; + +var uncurryThis$c = functionUncurryThis; + +var id = 0; +var postfix = Math.random(); +var toString$2 = uncurryThis$c(1.0.toString); + +var uid$2 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$2(++id + postfix, 36); +}; + +var global$9 = global$h; +var shared$2 = sharedExports; +var hasOwn$7 = hasOwnProperty_1; +var uid$1 = uid$2; +var NATIVE_SYMBOL = symbolConstructorDetection; +var USE_SYMBOL_AS_UID = useSymbolAsUid; + +var Symbol$1 = global$9.Symbol; +var WellKnownSymbolsStore = shared$2('wks'); +var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1; + +var wellKnownSymbol$a = function (name) { + if (!hasOwn$7(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$7(Symbol$1, name) + ? Symbol$1[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; +}; + +var call$a = functionCall; +var isObject$4 = isObject$8; +var isSymbol$1 = isSymbol$2; +var getMethod$2 = getMethod$3; +var ordinaryToPrimitive = ordinaryToPrimitive$1; +var wellKnownSymbol$9 = wellKnownSymbol$a; + +var $TypeError$8 = TypeError; +var TO_PRIMITIVE = wellKnownSymbol$9('toPrimitive'); + +// `ToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-toprimitive +var toPrimitive$1 = function (input, pref) { + if (!isObject$4(input) || isSymbol$1(input)) return input; + var exoticToPrim = getMethod$2(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$a(exoticToPrim, input, pref); + if (!isObject$4(result) || isSymbol$1(result)) return result; + throw new $TypeError$8("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); +}; + +var toPrimitive = toPrimitive$1; +var isSymbol = isSymbol$2; + +// `ToPropertyKey` abstract operation +// https://tc39.es/ecma262/#sec-topropertykey +var toPropertyKey$2 = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; +}; + +var DESCRIPTORS$6 = descriptors; +var IE8_DOM_DEFINE$1 = ie8DomDefine; +var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; +var anObject$7 = anObject$8; +var toPropertyKey$1 = toPropertyKey$2; + +var $TypeError$7 = TypeError; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var $defineProperty = Object.defineProperty; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; +var ENUMERABLE = 'enumerable'; +var CONFIGURABLE = 'configurable'; +var WRITABLE = 'writable'; + +// `Object.defineProperty` method +// https://tc39.es/ecma262/#sec-object.defineproperty +objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) { + anObject$7(O); + P = toPropertyKey$1(P); + anObject$7(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor$1(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); +} : $defineProperty : function defineProperty(O, P, Attributes) { + anObject$7(O); + P = toPropertyKey$1(P); + anObject$7(Attributes); + if (IE8_DOM_DEFINE$1) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$7('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + +var createPropertyDescriptor$2 = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + +var DESCRIPTORS$5 = descriptors; +var definePropertyModule$2 = objectDefineProperty; +var createPropertyDescriptor$1 = createPropertyDescriptor$2; + +var createNonEnumerableProperty$2 = DESCRIPTORS$5 ? function (object, key, value) { + return definePropertyModule$2.f(object, key, createPropertyDescriptor$1(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + +var shared$1 = sharedExports; +var uid = uid$2; + +var keys = shared$1('keys'); + +var sharedKey$1 = function (key) { + return keys[key] || (keys[key] = uid(key)); +}; + +var hiddenKeys$3 = {}; + +var NATIVE_WEAK_MAP = weakMapBasicDetection; +var global$8 = global$h; +var isObject$3 = isObject$8; +var createNonEnumerableProperty$1 = createNonEnumerableProperty$2; +var hasOwn$6 = hasOwnProperty_1; +var shared = sharedStore; +var sharedKey = sharedKey$1; +var hiddenKeys$2 = hiddenKeys$3; + +var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; +var TypeError$2 = global$8.TypeError; +var WeakMap = global$8.WeakMap; +var set$1, get, has; + +var enforce = function (it) { + return has(it) ? get(it) : set$1(it, {}); +}; + +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject$3(it) || (state = get(it)).type !== TYPE) { + throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; +}; + +if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set$1 = function (it, metadata) { + if (store.has(it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get = function (it) { + return store.get(it) || {}; + }; + has = function (it) { + return store.has(it); + }; +} else { + var STATE = sharedKey('state'); + hiddenKeys$2[STATE] = true; + set$1 = function (it, metadata) { + if (hasOwn$6(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty$1(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn$6(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn$6(it, STATE); + }; +} + +var internalState = { + set: set$1, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor +}; + +var uncurryThis$b = functionUncurryThis; +var fails$5 = fails$b; +var isCallable$9 = isCallable$h; +var hasOwn$5 = hasOwnProperty_1; +var DESCRIPTORS$4 = descriptors; +var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE; +var inspectSource$2 = inspectSource$3; +var InternalStateModule$1 = internalState; + +var enforceInternalState = InternalStateModule$1.enforce; +var getInternalState = InternalStateModule$1.get; +var $String$1 = String; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty$3 = Object.defineProperty; +var stringSlice$1 = uncurryThis$b(''.slice); +var replace = uncurryThis$b(''.replace); +var join = uncurryThis$b([].join); + +var CONFIGURABLE_LENGTH = DESCRIPTORS$4 && !fails$5(function () { + return defineProperty$3(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; +}); + +var TEMPLATE = String(String).split('String'); + +var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) { + if (stringSlice$1($String$1(name), 0, 7) === 'Symbol(') { + name = '[' + replace($String$1(name), /^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn$5(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) { + if (DESCRIPTORS$4) defineProperty$3(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn$5(options, 'arity') && value.length !== options.arity) { + defineProperty$3(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn$5(options, 'constructor') && options.constructor) { + if (DESCRIPTORS$4) defineProperty$3(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn$5(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; +}; + +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +// eslint-disable-next-line no-extend-native -- required +Function.prototype.toString = makeBuiltIn$2(function toString() { + return isCallable$9(this) && getInternalState(this).source || inspectSource$2(this); +}, 'toString'); + +var makeBuiltInExports = makeBuiltIn$3.exports; + +var makeBuiltIn$1 = makeBuiltInExports; +var defineProperty$2 = objectDefineProperty; + +var defineBuiltInAccessor$2 = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn$1(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn$1(descriptor.set, name, { setter: true }); + return defineProperty$2.f(target, name, descriptor); +}; + +var DESCRIPTORS$3 = descriptors; +var FUNCTION_NAME_EXISTS = functionName.EXISTS; +var uncurryThis$a = functionUncurryThis; +var defineBuiltInAccessor$1 = defineBuiltInAccessor$2; + +var FunctionPrototype$1 = Function.prototype; +var functionToString = uncurryThis$a(FunctionPrototype$1.toString); +var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; +var regExpExec = uncurryThis$a(nameRE.exec); +var NAME = 'name'; + +// Function instances `.name` property +// https://tc39.es/ecma262/#sec-function-instances-name +if (DESCRIPTORS$3 && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor$1(FunctionPrototype$1, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); +} + +var objectGetOwnPropertyDescriptor = {}; + +var objectPropertyIsEnumerable = {}; + +var $propertyIsEnumerable = {}.propertyIsEnumerable; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor; + +// Nashorn ~ JDK8 bug +var NASHORN_BUG = getOwnPropertyDescriptor$2 && !$propertyIsEnumerable.call({ 1: 2 }, 1); + +// `Object.prototype.propertyIsEnumerable` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable +objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor$2(this, V); + return !!descriptor && descriptor.enumerable; +} : $propertyIsEnumerable; + +var uncurryThis$9 = functionUncurryThis; + +var toString$1 = uncurryThis$9({}.toString); +var stringSlice = uncurryThis$9(''.slice); + +var classofRaw$2 = function (it) { + return stringSlice(toString$1(it), 8, -1); +}; + +var uncurryThis$8 = functionUncurryThis; +var fails$4 = fails$b; +var classof$5 = classofRaw$2; + +var $Object$1 = Object; +var split = uncurryThis$8(''.split); + +// fallback for non-array-like ES3 and non-enumerable old V8 strings +var indexedObject = fails$4(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object$1('z').propertyIsEnumerable(0); +}) ? function (it) { + return classof$5(it) === 'String' ? split(it, '') : $Object$1(it); +} : $Object$1; + +// toObject with fallback for non-array-like ES3 strings +var IndexedObject$1 = indexedObject; +var requireObjectCoercible = requireObjectCoercible$2; + +var toIndexedObject$3 = function (it) { + return IndexedObject$1(requireObjectCoercible(it)); +}; + +var DESCRIPTORS$2 = descriptors; +var call$9 = functionCall; +var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; +var createPropertyDescriptor = createPropertyDescriptor$2; +var toIndexedObject$2 = toIndexedObject$3; +var toPropertyKey = toPropertyKey$2; +var hasOwn$4 = hasOwnProperty_1; +var IE8_DOM_DEFINE = ie8DomDefine; + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor +objectGetOwnPropertyDescriptor.f = DESCRIPTORS$2 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$2(O); + P = toPropertyKey(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn$4(O, P)) return createPropertyDescriptor(!call$9(propertyIsEnumerableModule$1.f, O, P), O[P]); +}; + +var isCallable$8 = isCallable$h; +var definePropertyModule$1 = objectDefineProperty; +var makeBuiltIn = makeBuiltInExports; +var defineGlobalProperty$1 = defineGlobalProperty$3; + +var defineBuiltIn$4 = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable$8(value)) makeBuiltIn(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty$1(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule$1.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; +}; + +var objectGetOwnPropertyNames = {}; + +var ceil = Math.ceil; +var floor = Math.floor; + +// `Math.trunc` method +// https://tc39.es/ecma262/#sec-math.trunc +// eslint-disable-next-line es/no-math-trunc -- safe +var mathTrunc = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor : ceil)(n); +}; + +var trunc = mathTrunc; + +// `ToIntegerOrInfinity` abstract operation +// https://tc39.es/ecma262/#sec-tointegerorinfinity +var toIntegerOrInfinity$2 = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); +}; + +var toIntegerOrInfinity$1 = toIntegerOrInfinity$2; + +var max = Math.max; +var min$1 = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). +var toAbsoluteIndex$1 = function (index, length) { + var integer = toIntegerOrInfinity$1(index); + return integer < 0 ? max(integer + length, 0) : min$1(integer, length); +}; + +var toIntegerOrInfinity = toIntegerOrInfinity$2; + +var min = Math.min; + +// `ToLength` abstract operation +// https://tc39.es/ecma262/#sec-tolength +var toLength$1 = function (argument) { + return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + +var toLength = toLength$1; + +// `LengthOfArrayLike` abstract operation +// https://tc39.es/ecma262/#sec-lengthofarraylike +var lengthOfArrayLike$2 = function (obj) { + return toLength(obj.length); +}; + +var toIndexedObject$1 = toIndexedObject$3; +var toAbsoluteIndex = toAbsoluteIndex$1; +var lengthOfArrayLike$1 = lengthOfArrayLike$2; + +// `Array.prototype.{ indexOf, includes }` methods implementation +var createMethod = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject$1($this); + var length = lengthOfArrayLike$1(O); + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod(false) +}; + +var uncurryThis$7 = functionUncurryThis; +var hasOwn$3 = hasOwnProperty_1; +var toIndexedObject = toIndexedObject$3; +var indexOf = arrayIncludes.indexOf; +var hiddenKeys$1 = hiddenKeys$3; + +var push = uncurryThis$7([].push); + +var objectKeysInternal = function (object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn$3(hiddenKeys$1, key) && hasOwn$3(O, key) && push(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn$3(O, key = names[i++])) { + ~indexOf(result, key) || push(result, key); + } + return result; +}; + +// IE8- don't enum bug keys +var enumBugKeys$2 = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + +var internalObjectKeys$1 = objectKeysInternal; +var enumBugKeys$1 = enumBugKeys$2; + +var hiddenKeys = enumBugKeys$1.concat('length', 'prototype'); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +// eslint-disable-next-line es/no-object-getownpropertynames -- safe +objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys); +}; + +var objectGetOwnPropertySymbols = {}; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe +objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; + +var getBuiltIn$5 = getBuiltIn$7; +var uncurryThis$6 = functionUncurryThis; +var getOwnPropertyNamesModule = objectGetOwnPropertyNames; +var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; +var anObject$6 = anObject$8; + +var concat$1 = uncurryThis$6([].concat); + +// all object keys, includes non-enumerable and symbols +var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject$6(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f; + return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys; +}; + +var hasOwn$2 = hasOwnProperty_1; +var ownKeys = ownKeys$1; +var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; +var definePropertyModule = objectDefineProperty; + +var copyConstructorProperties$1 = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn$2(target, key) && !(exceptions && hasOwn$2(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } +}; + +var fails$3 = fails$b; +var isCallable$7 = isCallable$h; + +var replacement = /#|\.prototype\./; + +var isForced$2 = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable$7(detection) ? fails$3(detection) + : !!detection; +}; + +var normalize = isForced$2.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced$2.data = {}; +var NATIVE = isForced$2.NATIVE = 'N'; +var POLYFILL = isForced$2.POLYFILL = 'P'; + +var isForced_1 = isForced$2; + +var global$7 = global$h; +var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; +var createNonEnumerableProperty = createNonEnumerableProperty$2; +var defineBuiltIn$3 = defineBuiltIn$4; +var defineGlobalProperty = defineGlobalProperty$3; +var copyConstructorProperties = copyConstructorProperties$1; +var isForced$1 = isForced_1; + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key +*/ +var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global$7; + } else if (STATIC) { + target = global$7[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = (global$7[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor$1(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced$1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty(sourceProperty, 'sham', true); + } + defineBuiltIn$3(target, key, sourceProperty, options); + } +}; + +var internalObjectKeys = objectKeysInternal; +var enumBugKeys = enumBugKeys$2; + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +// eslint-disable-next-line es/no-object-keys -- safe +var objectKeys$1 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys); +}; + +var DESCRIPTORS$1 = descriptors; +var uncurryThis$5 = functionUncurryThis; +var call$8 = functionCall; +var fails$2 = fails$b; +var objectKeys = objectKeys$1; +var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; +var propertyIsEnumerableModule = objectPropertyIsEnumerable; +var toObject = toObject$2; +var IndexedObject = indexedObject; + +// eslint-disable-next-line es/no-object-assign -- safe +var $assign = Object.assign; +// eslint-disable-next-line es/no-object-defineproperty -- required for testing +var defineProperty$1 = Object.defineProperty; +var concat = uncurryThis$5([].concat); + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +var objectAssign = !$assign || fails$2(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$1 && $assign({ b: 1 }, $assign(defineProperty$1({}, 'a', { + enumerable: true, + get: function () { + defineProperty$1(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet; +}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$1 || call$8(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; +} : $assign; + +var $$6 = _export; +var assign = objectAssign; + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +// eslint-disable-next-line es/no-object-assign -- required for testing +$$6({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign +}); + +var wellKnownSymbol$8 = wellKnownSymbol$a; + +var TO_STRING_TAG$2 = wellKnownSymbol$8('toStringTag'); +var test = {}; + +test[TO_STRING_TAG$2] = 'z'; + +var toStringTagSupport = String(test) === '[object z]'; + +var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; +var isCallable$6 = isCallable$h; +var classofRaw$1 = classofRaw$2; +var wellKnownSymbol$7 = wellKnownSymbol$a; + +var TO_STRING_TAG$1 = wellKnownSymbol$7('toStringTag'); +var $Object = Object; + +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +var classof$4 = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw$1(O) + // ES3 arguments fallback + : (result = classofRaw$1(O)) === 'Object' && isCallable$6(O.callee) ? 'Arguments' : result; +}; + +var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; +var classof$3 = classof$4; + +// `Object.prototype.toString` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.tostring +var objectToString$1 = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$3(this) + ']'; +}; + +var TO_STRING_TAG_SUPPORT = toStringTagSupport; +var defineBuiltIn$2 = defineBuiltIn$4; +var toString = objectToString$1; + +// `Object.prototype.toString` method +// https://tc39.es/ecma262/#sec-object.prototype.tostring +if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn$2(Object.prototype, 'toString', toString, { unsafe: true }); +} + +var global$6 = global$h; +var classof$2 = classofRaw$2; + +var engineIsNode = classof$2(global$6.process) === 'process'; + +var uncurryThis$4 = functionUncurryThis; +var aCallable$6 = aCallable$8; + +var functionUncurryThisAccessor = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis$4(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } +}; + +var isCallable$5 = isCallable$h; + +var $String = String; +var $TypeError$6 = TypeError; + +var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$5(argument)) return argument; + throw new $TypeError$6("Can't set " + $String(argument) + ' as a prototype'); +}; + +/* eslint-disable no-proto -- safe */ +var uncurryThisAccessor = functionUncurryThisAccessor; +var anObject$5 = anObject$8; +var aPossiblePrototype = aPossiblePrototype$1; + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +// Works with __proto__ only. Old v8 can't work with null proto objects. +// eslint-disable-next-line es/no-object-setprototypeof -- safe +var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject$5(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + +var defineProperty = objectDefineProperty.f; +var hasOwn$1 = hasOwnProperty_1; +var wellKnownSymbol$6 = wellKnownSymbol$a; + +var TO_STRING_TAG = wellKnownSymbol$6('toStringTag'); + +var setToStringTag$1 = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$1(target, TO_STRING_TAG)) { + defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + +var getBuiltIn$4 = getBuiltIn$7; +var defineBuiltInAccessor = defineBuiltInAccessor$2; +var wellKnownSymbol$5 = wellKnownSymbol$a; +var DESCRIPTORS = descriptors; + +var SPECIES$2 = wellKnownSymbol$5('species'); + +var setSpecies$1 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME); + + if (DESCRIPTORS && Constructor && !Constructor[SPECIES$2]) { + defineBuiltInAccessor(Constructor, SPECIES$2, { + configurable: true, + get: function () { return this; } + }); + } +}; + +var isPrototypeOf$1 = objectIsPrototypeOf; + +var $TypeError$5 = TypeError; + +var anInstance$1 = function (it, Prototype) { + if (isPrototypeOf$1(Prototype, it)) return it; + throw new $TypeError$5('Incorrect invocation'); +}; + +var uncurryThis$3 = functionUncurryThis; +var fails$1 = fails$b; +var isCallable$4 = isCallable$h; +var classof$1 = classof$4; +var getBuiltIn$3 = getBuiltIn$7; +var inspectSource$1 = inspectSource$3; + +var noop = function () { /* empty */ }; +var empty = []; +var construct = getBuiltIn$3('Reflect', 'construct'); +var constructorRegExp = /^\s*(?:class|function)\b/; +var exec = uncurryThis$3(constructorRegExp.exec); +var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + +var isConstructorModern = function isConstructor(argument) { + if (!isCallable$4(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } +}; + +var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$4(argument)) return false; + switch (classof$1(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } +}; + +isConstructorLegacy.sham = true; + +// `IsConstructor` abstract operation +// https://tc39.es/ecma262/#sec-isconstructor +var isConstructor$1 = !construct || fails$1(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; +}) ? isConstructorLegacy : isConstructorModern; + +var isConstructor = isConstructor$1; +var tryToString$2 = tryToString$4; + +var $TypeError$4 = TypeError; + +// `Assert: IsConstructor(argument) is true` +var aConstructor$1 = function (argument) { + if (isConstructor(argument)) return argument; + throw new $TypeError$4(tryToString$2(argument) + ' is not a constructor'); +}; + +var anObject$4 = anObject$8; +var aConstructor = aConstructor$1; +var isNullOrUndefined$1 = isNullOrUndefined$4; +var wellKnownSymbol$4 = wellKnownSymbol$a; + +var SPECIES$1 = wellKnownSymbol$4('species'); + +// `SpeciesConstructor` abstract operation +// https://tc39.es/ecma262/#sec-speciesconstructor +var speciesConstructor$1 = function (O, defaultConstructor) { + var C = anObject$4(O).constructor; + var S; + return C === undefined || isNullOrUndefined$1(S = anObject$4(C)[SPECIES$1]) ? defaultConstructor : aConstructor(S); +}; + +var NATIVE_BIND$1 = functionBindNative; + +var FunctionPrototype = Function.prototype; +var apply$1 = FunctionPrototype.apply; +var call$7 = FunctionPrototype.call; + +// eslint-disable-next-line es/no-reflect -- safe +var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$7.bind(apply$1) : function () { + return call$7.apply(apply$1, arguments); +}); + +var classofRaw = classofRaw$2; +var uncurryThis$2 = functionUncurryThis; + +var functionUncurryThisClause = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis$2(fn); +}; + +var uncurryThis$1 = functionUncurryThisClause; +var aCallable$5 = aCallable$8; +var NATIVE_BIND = functionBindNative; + +var bind$4 = uncurryThis$1(uncurryThis$1.bind); + +// optional / simple context binding +var functionBindContext = function (fn, that) { + aCallable$5(fn); + return that === undefined ? fn : NATIVE_BIND ? bind$4(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; +}; + +var getBuiltIn$2 = getBuiltIn$7; + +var html$1 = getBuiltIn$2('document', 'documentElement'); + +var uncurryThis = functionUncurryThis; + +var arraySlice$1 = uncurryThis([].slice); + +var $TypeError$3 = TypeError; + +var validateArgumentsLength$1 = function (passed, required) { + if (passed < required) throw new $TypeError$3('Not enough arguments'); + return passed; +}; + +var userAgent$2 = engineUserAgent; + +// eslint-disable-next-line redos/no-vulnerable -- safe +var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2); + +var global$5 = global$h; +var apply = functionApply; +var bind$3 = functionBindContext; +var isCallable$3 = isCallable$h; +var hasOwn = hasOwnProperty_1; +var fails = fails$b; +var html = html$1; +var arraySlice = arraySlice$1; +var createElement = documentCreateElement; +var validateArgumentsLength = validateArgumentsLength$1; +var IS_IOS$1 = engineIsIos; +var IS_NODE$3 = engineIsNode; + +var set = global$5.setImmediate; +var clear = global$5.clearImmediate; +var process$2 = global$5.process; +var Dispatch = global$5.Dispatch; +var Function$1 = global$5.Function; +var MessageChannel = global$5.MessageChannel; +var String$1 = global$5.String; +var counter = 0; +var queue$2 = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var $location, defer, channel, port; + +fails(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = global$5.location; +}); + +var run = function (id) { + if (hasOwn(queue$2, id)) { + var fn = queue$2[id]; + delete queue$2[id]; + fn(); + } +}; + +var runner = function (id) { + return function () { + run(id); + }; +}; + +var eventListener = function (event) { + run(event.data); +}; + +var globalPostMessageDefer = function (id) { + // old engines have not location.origin + global$5.postMessage(String$1(id), $location.protocol + '//' + $location.host); +}; + +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!set || !clear) { + set = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable$3(handler) ? handler : Function$1(handler); + var args = arraySlice(arguments, 1); + queue$2[++counter] = function () { + apply(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue$2[id]; + }; + // Node.js 0.8- + if (IS_NODE$3) { + defer = function (id) { + process$2.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS$1) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind$3(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global$5.addEventListener && + isCallable$3(global$5.postMessage) && + !global$5.importScripts && + $location && $location.protocol !== 'file:' && + !fails(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + global$5.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } +} + +var task$1 = { + set: set, + clear: clear +}; + +var Queue$2 = function () { + this.head = null; + this.tail = null; +}; + +Queue$2.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } +}; + +var queue$1 = Queue$2; + +var userAgent$1 = engineUserAgent; + +var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && typeof Pebble != 'undefined'; + +var userAgent = engineUserAgent; + +var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent); + +var global$4 = global$h; +var bind$2 = functionBindContext; +var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; +var macrotask = task$1.set; +var Queue$1 = queue$1; +var IS_IOS = engineIsIos; +var IS_IOS_PEBBLE = engineIsIosPebble; +var IS_WEBOS_WEBKIT = engineIsWebosWebkit; +var IS_NODE$2 = engineIsNode; + +var MutationObserver = global$4.MutationObserver || global$4.WebKitMutationObserver; +var document$2 = global$4.document; +var process$1 = global$4.process; +var Promise$1 = global$4.Promise; +// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` +var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$4, 'queueMicrotask'); +var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; +var notify$1, toggle, node, promise, then; + +// modern engines have queueMicrotask method +if (!microtask$1) { + var queue = new Queue$1(); + + var flush = function () { + var parent, fn; + if (IS_NODE$2 && (parent = process$1.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify$1(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { + toggle = true; + node = document$2.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify$1 = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise$1.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise$1; + then = bind$2(promise.then, promise); + notify$1 = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE$2) { + notify$1 = function () { + process$1.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind$2(macrotask, global$4); + notify$1 = function () { + macrotask(flush); + }; + } + + microtask$1 = function (fn) { + if (!queue.head) notify$1(); + queue.add(fn); + }; +} + +var microtask_1 = microtask$1; + +var hostReportErrors$1 = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } +}; + +var perform$3 = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } +}; + +var global$3 = global$h; + +var promiseNativeConstructor = global$3.Promise; + +/* global Deno -- Deno case */ +var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object'; + +var IS_DENO$1 = engineIsDeno; +var IS_NODE$1 = engineIsNode; + +var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 + && typeof window == 'object' + && typeof document == 'object'; + +var global$2 = global$h; +var NativePromiseConstructor$3 = promiseNativeConstructor; +var isCallable$2 = isCallable$h; +var isForced = isForced_1; +var inspectSource = inspectSource$3; +var wellKnownSymbol$3 = wellKnownSymbol$a; +var IS_BROWSER = engineIsBrowser; +var IS_DENO = engineIsDeno; +var V8_VERSION = engineV8Version; + +NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype; +var SPECIES = wellKnownSymbol$3('species'); +var SUBCLASSING = false; +var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$2(global$2.PromiseRejectionEvent); + +var FORCED_PROMISE_CONSTRUCTOR$5 = isForced('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1; +}); + +var promiseConstructorDetection = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1, + SUBCLASSING: SUBCLASSING +}; + +var newPromiseCapability$2 = {}; + +var aCallable$4 = aCallable$8; + +var $TypeError$2 = TypeError; + +var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError$2('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable$4(resolve); + this.reject = aCallable$4(reject); +}; + +// `NewPromiseCapability` abstract operation +// https://tc39.es/ecma262/#sec-newpromisecapability +newPromiseCapability$2.f = function (C) { + return new PromiseCapability(C); +}; + +var $$5 = _export; +var IS_NODE = engineIsNode; +var global$1 = global$h; +var call$6 = functionCall; +var defineBuiltIn$1 = defineBuiltIn$4; +var setPrototypeOf = objectSetPrototypeOf; +var setToStringTag = setToStringTag$1; +var setSpecies = setSpecies$1; +var aCallable$3 = aCallable$8; +var isCallable$1 = isCallable$h; +var isObject$2 = isObject$8; +var anInstance = anInstance$1; +var speciesConstructor = speciesConstructor$1; +var task = task$1.set; +var microtask = microtask_1; +var hostReportErrors = hostReportErrors$1; +var perform$2 = perform$3; +var Queue = queue$1; +var InternalStateModule = internalState; +var NativePromiseConstructor$2 = promiseNativeConstructor; +var PromiseConstructorDetection = promiseConstructorDetection; +var newPromiseCapabilityModule$3 = newPromiseCapability$2; + +var PROMISE = 'Promise'; +var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR; +var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; +var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; +var getInternalPromiseState = InternalStateModule.getterFor(PROMISE); +var setInternalState = InternalStateModule.set; +var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype; +var PromiseConstructor = NativePromiseConstructor$2; +var PromisePrototype = NativePromisePrototype$1; +var TypeError$1 = global$1.TypeError; +var document$1 = global$1.document; +var process = global$1.process; +var newPromiseCapability$1 = newPromiseCapabilityModule$3.f; +var newGenericPromiseCapability = newPromiseCapability$1; + +var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$1.dispatchEvent); +var UNHANDLED_REJECTION = 'unhandledrejection'; +var REJECTION_HANDLED = 'rejectionhandled'; +var PENDING = 0; +var FULFILLED = 1; +var REJECTED = 2; +var HANDLED = 1; +var UNHANDLED = 2; + +var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + +// helpers +var isThenable = function (it) { + var then; + return isObject$2(it) && isCallable$1(then = it.then) ? then : false; +}; + +var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$6(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } +}; + +var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); +}; + +var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$1.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global$1.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$1['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); +}; + +var onUnhandled = function (state) { + call$6(task, global$1, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform$2(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); +}; + +var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; +}; + +var onHandleUnhandled = function (state) { + call$6(task, global$1, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); +}; + +var bind$1 = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; +}; + +var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); +}; + +var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call$6(then, value, + bind$1(internalResolve, wrapper, state), + bind$1(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } +}; + +// constructor polyfill +if (FORCED_PROMISE_CONSTRUCTOR$4) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance(this, PromisePrototype); + aCallable$3(executor); + call$6(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind$1(internalResolve, state), bind$1(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: undefined + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn$1(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable$1(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$1(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind$1(internalResolve, state); + this.reject = bind$1(internalReject, state); + }; + + newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (isCallable$1(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) { + nativeThen = NativePromisePrototype$1.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn$1(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call$6(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype$1.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf) { + setPrototypeOf(NativePromisePrototype$1, PromisePrototype); + } + } +} + +$$5({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, { + Promise: PromiseConstructor +}); + +setToStringTag(PromiseConstructor, PROMISE, false); +setSpecies(PROMISE); + +var iterators = {}; + +var wellKnownSymbol$2 = wellKnownSymbol$a; +var Iterators$1 = iterators; + +var ITERATOR$2 = wellKnownSymbol$2('iterator'); +var ArrayPrototype = Array.prototype; + +// check on default Array iterator +var isArrayIteratorMethod$1 = function (it) { + return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$2] === it); +}; + +var classof = classof$4; +var getMethod$1 = getMethod$3; +var isNullOrUndefined = isNullOrUndefined$4; +var Iterators = iterators; +var wellKnownSymbol$1 = wellKnownSymbol$a; + +var ITERATOR$1 = wellKnownSymbol$1('iterator'); + +var getIteratorMethod$2 = function (it) { + if (!isNullOrUndefined(it)) return getMethod$1(it, ITERATOR$1) + || getMethod$1(it, '@@iterator') + || Iterators[classof(it)]; +}; + +var call$5 = functionCall; +var aCallable$2 = aCallable$8; +var anObject$3 = anObject$8; +var tryToString$1 = tryToString$4; +var getIteratorMethod$1 = getIteratorMethod$2; + +var $TypeError$1 = TypeError; + +var getIterator$1 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator; + if (aCallable$2(iteratorMethod)) return anObject$3(call$5(iteratorMethod, argument)); + throw new $TypeError$1(tryToString$1(argument) + ' is not iterable'); +}; + +var call$4 = functionCall; +var anObject$2 = anObject$8; +var getMethod = getMethod$3; + +var iteratorClose$1 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$2(iterator); + try { + innerResult = getMethod(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$4(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$2(innerResult); + return value; +}; + +var bind = functionBindContext; +var call$3 = functionCall; +var anObject$1 = anObject$8; +var tryToString = tryToString$4; +var isArrayIteratorMethod = isArrayIteratorMethod$1; +var lengthOfArrayLike = lengthOfArrayLike$2; +var isPrototypeOf = objectIsPrototypeOf; +var getIterator = getIterator$1; +var getIteratorMethod = getIteratorMethod$2; +var iteratorClose = iteratorClose$1; + +var $TypeError = TypeError; + +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; + +var ResultPrototype = Result.prototype; + +var iterate$2 = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject$1(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call$3(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); +}; + +var wellKnownSymbol = wellKnownSymbol$a; + +var ITERATOR = wellKnownSymbol('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + +var NativePromiseConstructor$1 = promiseNativeConstructor; +var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1; +var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR; + +var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration(function (iterable) { + NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ }); +}); + +var $$4 = _export; +var call$2 = functionCall; +var aCallable$1 = aCallable$8; +var newPromiseCapabilityModule$2 = newPromiseCapability$2; +var perform$1 = perform$3; +var iterate$1 = iterate$2; +var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration; + +// `Promise.all` method +// https://tc39.es/ecma262/#sec-promise.all +$$4({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$2.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform$1(function () { + var $promiseResolve = aCallable$1(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$1(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$2($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var $$3 = _export; +var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR; +var NativePromiseConstructor = promiseNativeConstructor; +var getBuiltIn$1 = getBuiltIn$7; +var isCallable = isCallable$h; +var defineBuiltIn = defineBuiltIn$4; + +var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + +// `Promise.prototype.catch` method +// https://tc39.es/ecma262/#sec-promise.prototype.catch +$$3({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } +}); + +// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` +if (isCallable(NativePromiseConstructor)) { + var method = getBuiltIn$1('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true }); + } +} + +var $$2 = _export; +var call$1 = functionCall; +var aCallable = aCallable$8; +var newPromiseCapabilityModule$1 = newPromiseCapability$2; +var perform = perform$3; +var iterate = iterate$2; +var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration; + +// `Promise.race` method +// https://tc39.es/ecma262/#sec-promise.race +$$2({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$1.f(C); + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aCallable(C.resolve); + iterate(iterable, function (promise) { + call$1($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var $$1 = _export; +var call = functionCall; +var newPromiseCapabilityModule = newPromiseCapability$2; +var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR; + +// `Promise.reject` method +// https://tc39.es/ecma262/#sec-promise.reject +$$1({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule.f(this); + call(capability.reject, undefined, r); + return capability.promise; + } +}); + +var anObject = anObject$8; +var isObject$1 = isObject$8; +var newPromiseCapability = newPromiseCapability$2; + +var promiseResolve$1 = function (C, x) { + anObject(C); + if (isObject$1(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + +var $ = _export; +var getBuiltIn = getBuiltIn$7; +var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR; +var promiseResolve = promiseResolve$1; + +getBuiltIn('Promise'); + +// `Promise.resolve` method +// https://tc39.es/ecma262/#sec-promise.resolve +$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(this, x); + } +}); + +function defined(x) { + return x != null && !Number.isNaN(x); +} + +function ascendingDefined(a, b) { + return +defined(b) - +defined(a) || ascending(a, b); +} + +function finite(x) { + return isFinite(x) ? x : NaN; +} + +function positive(x) { + return x > 0 && isFinite(x) ? x : NaN; +} + +function negative(x) { + return x < 0 && isFinite(x) ? x : NaN; +} + +function format(date, fallback) { + if (!(date instanceof Date)) date = new Date(+date); + if (isNaN(date)) return typeof fallback === "function" ? fallback(date) : fallback; + const hours = date.getUTCHours(); + const minutes = date.getUTCMinutes(); + const seconds = date.getUTCSeconds(); + const milliseconds = date.getUTCMilliseconds(); + return `${formatYear(date.getUTCFullYear())}-${pad(date.getUTCMonth() + 1, 2)}-${pad(date.getUTCDate(), 2)}${ + hours || minutes || seconds || milliseconds ? `T${pad(hours, 2)}:${pad(minutes, 2)}${ + seconds || milliseconds ? `:${pad(seconds, 2)}${ + milliseconds ? `.${pad(milliseconds, 3)}` : `` + }` : `` + }Z` : `` + }`; +} + +function formatYear(year) { + return year < 0 ? `-${pad(-year, 6)}` + : year > 9999 ? `+${pad(year, 6)}` + : pad(year, 4); +} + +function pad(value, width) { + return `${value}`.padStart(width, "0"); +} + +const re = /^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/; + +function parse(string, fallback) { + if (!re.test(string += "")) return typeof fallback === "function" ? fallback(string) : fallback; + return new Date(string); +} + +const timeIntervals = new Map([ + ["second", timeSecond], + ["minute", timeMinute], + ["hour", timeHour], + ["day", timeDay], + ["week", timeWeek], + ["month", timeMonth], + ["quarter", timeMonth.every(3)], + ["half", timeMonth.every(6)], + ["year", timeYear], + ["monday", timeMonday], + ["tuesday", timeTuesday], + ["wednesday", timeWednesday], + ["thursday", timeThursday], + ["friday", timeFriday], + ["saturday", timeSaturday], + ["sunday", timeSunday] +]); + +const utcIntervals = new Map([ + ["second", utcSecond], + ["minute", utcMinute], + ["hour", utcHour], + ["day", utcDay], + ["week", utcWeek], + ["month", utcMonth], + ["quarter", utcMonth.every(3)], + ["half", utcMonth.every(6)], + ["year", utcYear], + ["monday", utcMonday], + ["tuesday", utcTuesday], + ["wednesday", utcWednesday], + ["thursday", utcThursday], + ["friday", utcFriday], + ["saturday", utcSaturday], + ["sunday", utcSunday] +]); + +function maybeTimeInterval(interval) { + const i = timeIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; +} + +function maybeUtcInterval(interval) { + const i = utcIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; +} + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray +const TypedArray = Object.getPrototypeOf(Uint8Array); +const objectToString = Object.prototype.toString; +const string = (x) => (x == null ? x : `${x}`); +const constant = (x) => () => x; + +// If the values are specified as a typed array, no coercion is required. +function coerceNumbers(values) { + return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array); +} + +// Unlike Mark’s number, here we want to convert null and undefined to NaN since +// the result will be stored in a Float64Array and we don’t want null to be +// coerced to zero. We use Number instead of unary + to allow BigInt coercion. +function coerceNumber(x) { + return x == null ? NaN : Number(x); +} + +function coerceDates(values) { + return map(values, coerceDate); +} + +// When coercing strings to dates, we only want to allow the ISO 8601 format +// since the built-in string parsing of the Date constructor varies across +// browsers. (In the future, this could be made more liberal if desired, though +// it is still generally preferable to do date parsing yourself explicitly, +// rather than rely on Plot.) Any non-string values are coerced to number first +// and treated as milliseconds since UNIX epoch. +function coerceDate(x) { + return x instanceof Date && !isNaN(x) + ? x + : typeof x === "string" + ? parse(x) + : x == null || isNaN((x = +x)) + ? undefined + : new Date(x); +} + +// Some channels may allow a string constant to be specified; to differentiate +// string constants (e.g., "red") from named fields (e.g., "date"), this +// function tests whether the given value is a CSS color string and returns a +// tuple [channel, constant] where one of the two is undefined, and the other is +// the given value. If you wish to reference a named field that is also a valid +// CSS color, use an accessor (d => d.red) instead. +function maybeColorChannel(value, defaultValue) { + if (value === undefined) value = defaultValue; + return value === null ? [undefined, "none"] : isColor(value) ? [undefined, value] : [value, undefined]; +} + +// Similar to maybeColorChannel, this tests whether the given value is a number +// indicating a constant, and otherwise assumes that it’s a channel value. +function maybeNumberChannel(value, defaultValue) { + if (value === undefined) value = defaultValue; + return value === null || typeof value === "number" ? [undefined, value] : [value, undefined]; +} + +// Promotes the specified data to an array as needed. +function arrayify(data) { + return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data); +} + +// An optimization of type.from(values, f): if the given values are already an +// instanceof the desired array type, the faster values.map method is used. +function map(values, f, type = Array) { + return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f); +} + +// An optimization of type.from(values): if the given values are already an +// instanceof the desired array type, the faster values.slice method is used. +function slice(values, type = Array) { + return values instanceof type ? values.slice() : type.from(values); +} + +// Disambiguates an options object (e.g., {y: "x2"}) from a primitive value. +function isObject(option) { + return option?.toString === objectToString; +} + +// Disambiguates a scale options object (e.g., {color: {type: "linear"}}) from +// some other option (e.g., {color: "red"}). When creating standalone legends, +// this is used to test whether a scale is defined; this should be consistent +// with inferScaleType when there are no channels associated with the scale, and +// if this returns true, then normalizeScale must return non-null. +function isScaleOptions(option) { + return isObject(option) && (option.type !== undefined || option.domain !== undefined); +} + +// If interval is not nullish, converts interval shorthand such as a number (for +// multiples) or a time interval name (such as “day”) to a {floor, offset, +// range} object similar to a D3 time interval. +function maybeInterval(interval, type) { + if (interval == null) return; + if (typeof interval === "number") { + if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval; + const n = Math.abs(interval); + return interval < 0 + ? { + floor: (d) => Math.floor(d * n) / n, + offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity + range: (lo, hi) => range(Math.ceil(lo * n), hi * n).map((x) => x / n) + } + : { + floor: (d) => Math.floor(d / n) * n, + offset: (d) => d + n, // note: no optional step for simplicity + range: (lo, hi) => range(Math.ceil(lo / n), hi / n).map((x) => x * n) + }; + } + if (typeof interval === "string") return (type === "time" ? maybeTimeInterval : maybeUtcInterval)(interval); + if (typeof interval.floor !== "function") throw new Error("invalid interval; missing floor method"); + if (typeof interval.offset !== "function") throw new Error("invalid interval; missing offset method"); + return interval; +} + +// Like maybeInterval, but requires a range method too. +function maybeRangeInterval(interval, type) { + interval = maybeInterval(interval, type); + if (interval && typeof interval.range !== "function") throw new Error("invalid interval: missing range method"); + return interval; +} + +// Like maybeRangeInterval, but requires a ceil method too. +function maybeNiceInterval(interval, type) { + interval = maybeRangeInterval(interval, type); + if (interval && typeof interval.ceil !== "function") throw new Error("invalid interval: missing ceil method"); + return interval; +} + +function isOrdinal(values) { + for (const value of values) { + if (value == null) continue; + const type = typeof value; + return type === "string" || type === "boolean"; + } +} + +function isTemporal(values) { + for (const value of values) { + if (value == null) continue; + return value instanceof Date; + } +} + +// Are these strings that might represent dates? This is stricter than ISO 8601 +// because we want to ignore false positives on numbers; for example, the string +// "1192" is more likely to represent a number than a date even though it is +// valid ISO 8601 representing 1192-01-01. +function isTemporalString(values) { + for (const value of values) { + if (value == null) continue; + return typeof value === "string" && isNaN(value) && parse(value); + } +} + +// Are these strings that might represent numbers? This is stricter than +// coercion because we want to ignore false positives on e.g. empty strings. +function isNumericString(values) { + for (const value of values) { + if (value == null) continue; + if (typeof value !== "string") return false; + if (!value.trim()) continue; + return !isNaN(value); + } +} + +// Mostly relies on d3-color, with a few extra color keywords. Currently this +// strictly requires that the value be a string; we might want to apply string +// coercion here, though note that d3-color instances would need to support +// valueOf to work correctly with InternMap. +// https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint +function isColor(value) { + if (typeof value !== "string") return false; + value = value.toLowerCase().trim(); + return ( + value === "none" || + value === "currentcolor" || + (value.startsWith("url(") && value.endsWith(")")) || // , e.g. pattern or gradient + (value.startsWith("var(") && value.endsWith(")")) || // CSS variable + color$1(value) !== null + ); +} + +function isNoneish(value) { + return value == null || isNone(value); +} + +function isNone(value) { + return /^\s*none\s*$/i.test(value); +} + +// Like a sort comparator, returns a positive value if the given array of values +// is in ascending order, a negative value if the values are in descending +// order. Assumes monotonicity; only tests the first and last values. +function orderof(values) { + if (values == null) return; + const first = values[0]; + const last = values[values.length - 1]; + return descending(first, last); +} + +// Unlike {...defaults, ...options}, this ensures that any undefined (but +// present) properties in options inherit the given default value. +function inherit(options = {}, ...rest) { + let o = options; + for (const defaults of rest) { + for (const key in defaults) { + if (o[key] === undefined) { + const value = defaults[key]; + if (o === options) o = {...o, [key]: value}; + else o[key] = value; + } + } + } + return o; +} + +// Positional scales have associated axes, and for ordinal data, a point or band +// scale is used instead of an ordinal scale. +const position = Symbol("position"); + +// Color scales default to the turbo interpolator for quantitative data, and to +// the Tableau10 scheme for ordinal data. Color scales may also have an +// associated legend. +const color = Symbol("color"); + +// Radius scales default to the sqrt type, have a default range of [0, 3], and a +// default domain from 0 to the median first quartile of associated channels. +const radius = Symbol("radius"); + +// Length scales default to the linear type, have a default range of [0, 12], +// and a default domain from 0 to the median median of associated channels. +const length = Symbol("length"); + +// Opacity scales have a default range of [0, 1], and a default domain from 0 to +// the maximum value of associated channels. +const opacity = Symbol("opacity"); + +// Symbol scales have a default range of categorical symbols. +const symbol = Symbol("symbol"); + +// TODO Rather than hard-coding the list of known scale names, collect the names +// and categories for each plot specification, so that custom marks can register +// custom scales. +const registry = new Map([ + ["x", position], + ["y", position], + ["fx", position], + ["fy", position], + ["r", radius], + ["color", color], + ["opacity", opacity], + ["symbol", symbol], + ["length", length] +]); + +const sqrt3 = Math.sqrt(3); +const sqrt4_3 = 2 / sqrt3; + +const symbolHexagon = { + draw(context, size) { + const rx = Math.sqrt(size / Math.PI), + ry = rx * sqrt4_3, + hy = ry / 2; + context.moveTo(0, ry); + context.lineTo(rx, hy); + context.lineTo(rx, -hy); + context.lineTo(0, -ry); + context.lineTo(-rx, -hy); + context.lineTo(-rx, hy); + context.closePath(); + } +}; + +const symbols = new Map([ + ["asterisk", symbolAsterisk], + ["circle", symbolCircle], + ["cross", symbolCross], + ["diamond", symbolDiamond], + ["diamond2", symbolDiamond2], + ["hexagon", symbolHexagon], + ["plus", symbolPlus], + ["square", symbolSquare], + ["square2", symbolSquare2], + ["star", symbolStar], + ["times", symbolTimes], + ["triangle", symbolTriangle], + ["triangle2", symbolTriangle2], + ["wye", symbolWye] +]); + +function isSymbolObject(value) { + return value && typeof value.draw === "function"; +} + +function maybeSymbol(symbol) { + if (symbol == null || isSymbolObject(symbol)) return symbol; + const value = symbols.get(`${symbol}`.toLowerCase()); + if (value) return value; + throw new Error(`invalid symbol: ${symbol}`); +} + +function warn(message) { + console.warn(message); +} + +const pi = Math.PI; +const tau = 2 * pi; + +function createProjection( + { + projection, + inset: globalInset = 0, + insetTop = globalInset, + insetRight = globalInset, + insetBottom = globalInset, + insetLeft = globalInset + } = {}, + dimensions +) { + if (projection == null) return; + if (typeof projection.stream === "function") return projection; // d3 projection + let options; + let domain; + let clip = "frame"; + + // If the projection was specified as an object with additional options, + // extract those. The order of precedence for insetTop (and other insets) is: + // projection.insetTop, projection.inset, (global) insetTop, (global) inset. + // Any other options on this object will be passed through to the initializer. + if (isObject(projection)) { + let inset; + ({ + type: projection, + domain, + inset, + insetTop = inset !== undefined ? inset : insetTop, + insetRight = inset !== undefined ? inset : insetRight, + insetBottom = inset !== undefined ? inset : insetBottom, + insetLeft = inset !== undefined ? inset : insetLeft, + clip = clip, + ...options + } = projection); + if (projection == null) return; + } + + // For named projections, retrieve the corresponding projection initializer. + if (typeof projection !== "function") ({type: projection} = namedProjection(projection)); + + // Compute the frame dimensions and invoke the projection initializer. + const {width, height, marginLeft, marginRight, marginTop, marginBottom} = dimensions; + const dx = width - marginLeft - marginRight - insetLeft - insetRight; + const dy = height - marginTop - marginBottom - insetTop - insetBottom; + projection = projection?.({width: dx, height: dy, clip, ...options}); + + // The projection initializer might decide to not use a projection. + if (projection == null) return; + clip = maybePostClip(clip, marginLeft, marginTop, width - marginRight, height - marginBottom); + + // Translate the origin to the top-left corner, respecting margins and insets. + let tx = marginLeft + insetLeft; + let ty = marginTop + insetTop; + let transform; + + // If a domain is specified, fit the projection to the frame. + if (domain != null) { + const [[x0, y0], [x1, y1]] = geoPath(projection).bounds(domain); + const k = Math.min(dx / (x1 - x0), dy / (y1 - y0)); + if (k > 0) { + tx -= (k * (x0 + x1) - dx) / 2; + ty -= (k * (y0 + y1) - dy) / 2; + transform = geoTransform({ + point(x, y) { + this.stream.point(x * k + tx, y * k + ty); + } + }); + } else { + warn(`Warning: the projection could not be fit to the specified domain; using the default scale.`); + } + } + + transform ??= + tx === 0 && ty === 0 + ? identity() + : geoTransform({ + point(x, y) { + this.stream.point(x + tx, y + ty); + } + }); + + return {stream: (s) => projection.stream(transform.stream(clip(s)))}; +} + +function namedProjection(projection) { + switch (`${projection}`.toLowerCase()) { + case "albers-usa": + return scaleProjection(geoAlbersUsa, 0.7463, 0.4673); + case "albers": + return conicProjection(geoAlbers, 0.7463, 0.4673); + case "azimuthal-equal-area": + return scaleProjection(geoAzimuthalEqualArea, 4, 4); + case "azimuthal-equidistant": + return scaleProjection(geoAzimuthalEquidistant, tau, tau); + case "conic-conformal": + return conicProjection(geoConicConformal, tau, tau); + case "conic-equal-area": + return conicProjection(geoConicEqualArea, 6.1702, 2.9781); + case "conic-equidistant": + return conicProjection(geoConicEquidistant, 7.312, 3.6282); + case "equal-earth": + return scaleProjection(geoEqualEarth, 5.4133, 2.6347); + case "equirectangular": + return scaleProjection(geoEquirectangular, tau, pi); + case "gnomonic": + return scaleProjection(geoGnomonic, 3.4641, 3.4641); + case "identity": + return {type: identity}; + case "reflect-y": + return {type: reflectY}; + case "mercator": + return scaleProjection(geoMercator, tau, tau); + case "orthographic": + return scaleProjection(geoOrthographic, 2, 2); + case "stereographic": + return scaleProjection(geoStereographic, 2, 2); + case "transverse-mercator": + return scaleProjection(geoTransverseMercator, tau, tau); + default: + throw new Error(`unknown projection type: ${projection}`); + } +} + +function maybePostClip(clip, x1, y1, x2, y2) { + if (clip === false || clip == null || typeof clip === "number") return (s) => s; + if (clip === true) clip = "frame"; + switch (`${clip}`.toLowerCase()) { + case "frame": + return geoClipRectangle(x1, y1, x2, y2); + default: + throw new Error(`unknown projection clip type: ${clip}`); + } +} + +function scaleProjection(createProjection, kx, ky) { + return { + type: ({width, height, rotate, precision = 0.15, clip}) => { + const projection = createProjection(); + if (precision != null) projection.precision?.(precision); + if (rotate != null) projection.rotate?.(rotate); + if (typeof clip === "number") projection.clipAngle?.(clip); + projection.scale(Math.min(width / kx, height / ky)); + projection.translate([width / 2, height / 2]); + return projection; + }, + aspectRatio: ky / kx + }; +} + +function conicProjection(createProjection, kx, ky) { + const {type, aspectRatio} = scaleProjection(createProjection, kx, ky); + return { + type: (options) => { + const {parallels, domain, width, height} = options; + const projection = type(options); + if (parallels != null) { + projection.parallels(parallels); + if (domain === undefined) { + projection.fitSize([width, height], {type: "Sphere"}); + } + } + return projection; + }, + aspectRatio + }; +} + +const identity = constant({stream: (stream) => stream}); + +const reflectY = constant( + geoTransform({ + point(x, y) { + this.stream.point(x, -y); + } + }) +); + +function createContext(options = {}, dimensions, className) { + const {document = typeof window !== "undefined" ? window.document : undefined} = options; + return {document, className, projection: createProjection(options, dimensions)}; +} + +function create(name, {document}) { + return select(creator(name).call(document.documentElement)); +} + +const ordinalSchemes = new Map([ + // categorical + ["accent", schemeAccent], + ["category10", schemeCategory10], + ["dark2", schemeDark2], + ["paired", schemePaired], + ["pastel1", schemePastel1], + ["pastel2", schemePastel2], + ["set1", schemeSet1], + ["set2", schemeSet2], + ["set3", schemeSet3], + ["tableau10", schemeTableau10], + + // diverging + ["brbg", scheme11(schemeBrBG, interpolateBrBG)], + ["prgn", scheme11(schemePRGn, interpolatePRGn)], + ["piyg", scheme11(schemePiYG, interpolatePiYG)], + ["puor", scheme11(schemePuOr, interpolatePuOr)], + ["rdbu", scheme11(schemeRdBu, interpolateRdBu)], + ["rdgy", scheme11(schemeRdGy, interpolateRdGy)], + ["rdylbu", scheme11(schemeRdYlBu, interpolateRdYlBu)], + ["rdylgn", scheme11(schemeRdYlGn, interpolateRdYlGn)], + ["spectral", scheme11(schemeSpectral, interpolateSpectral)], + + // reversed diverging (for temperature data) + ["burd", scheme11r(schemeRdBu, interpolateRdBu)], + ["buylrd", scheme11r(schemeRdYlBu, interpolateRdYlBu)], + + // sequential (single-hue) + ["blues", scheme9(schemeBlues, interpolateBlues)], + ["greens", scheme9(schemeGreens, interpolateGreens)], + ["greys", scheme9(schemeGreys, interpolateGreys)], + ["oranges", scheme9(schemeOranges, interpolateOranges)], + ["purples", scheme9(schemePurples, interpolatePurples)], + ["reds", scheme9(schemeReds, interpolateReds)], + + // sequential (multi-hue) + ["turbo", schemei(interpolateTurbo)], + ["viridis", schemei(interpolateViridis)], + ["magma", schemei(interpolateMagma)], + ["inferno", schemei(interpolateInferno)], + ["plasma", schemei(interpolatePlasma)], + ["cividis", schemei(interpolateCividis)], + ["cubehelix", schemei(interpolateCubehelixDefault)], + ["warm", schemei(interpolateWarm)], + ["cool", schemei(interpolateCool)], + ["bugn", scheme9(schemeBuGn, interpolateBuGn)], + ["bupu", scheme9(schemeBuPu, interpolateBuPu)], + ["gnbu", scheme9(schemeGnBu, interpolateGnBu)], + ["orrd", scheme9(schemeOrRd, interpolateOrRd)], + ["pubu", scheme9(schemePuBu, interpolatePuBu)], + ["pubugn", scheme9(schemePuBuGn, interpolatePuBuGn)], + ["purd", scheme9(schemePuRd, interpolatePuRd)], + ["rdpu", scheme9(schemeRdPu, interpolateRdPu)], + ["ylgn", scheme9(schemeYlGn, interpolateYlGn)], + ["ylgnbu", scheme9(schemeYlGnBu, interpolateYlGnBu)], + ["ylorbr", scheme9(schemeYlOrBr, interpolateYlOrBr)], + ["ylorrd", scheme9(schemeYlOrRd, interpolateYlOrRd)], + + // cyclical + ["rainbow", schemeicyclical(interpolateRainbow)], + ["sinebow", schemeicyclical(interpolateSinebow)] +]); + +function scheme9(scheme, interpolate) { + return ({length: n}) => { + if (n === 1) return [scheme[3][1]]; // favor midpoint + if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker + n = Math.max(3, Math.floor(n)); + return n > 9 ? quantize(interpolate, n) : scheme[n]; + }; +} + +function scheme11(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? quantize(interpolate, n) : scheme[n]; + }; +} + +function scheme11r(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse(); + }; +} + +function schemei(interpolate) { + return ({length: n}) => quantize(interpolate, Math.max(2, Math.floor(n))); +} + +function schemeicyclical(interpolate) { + return ({length: n}) => quantize(interpolate, Math.floor(n) + 1).slice(0, -1); +} + +function ordinalScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`); + return ordinalSchemes.get(s); +} + +function ordinalRange(scheme, length) { + const s = ordinalScheme(scheme); + const r = typeof s === "function" ? s({length}) : s; + return r.length !== length ? r.slice(0, length) : r; +} + +// If the specified domain contains only booleans (ignoring null and undefined), +// returns a corresponding range where false is mapped to the low color and true +// is mapped to the high color of the specified scheme. +function maybeBooleanRange(domain, scheme = "greys") { + const range = new Set(); + const [f, t] = ordinalRange(scheme, 2); + for (const value of domain) { + if (value == null) continue; + if (value === true) range.add(t); + else if (value === false) range.add(f); + else return; + } + return [...range]; +} + +const quantitativeSchemes = new Map([ + // diverging + ["brbg", interpolateBrBG], + ["prgn", interpolatePRGn], + ["piyg", interpolatePiYG], + ["puor", interpolatePuOr], + ["rdbu", interpolateRdBu], + ["rdgy", interpolateRdGy], + ["rdylbu", interpolateRdYlBu], + ["rdylgn", interpolateRdYlGn], + ["spectral", interpolateSpectral], + + // reversed diverging (for temperature data) + ["burd", (t) => interpolateRdBu(1 - t)], + ["buylrd", (t) => interpolateRdYlBu(1 - t)], + + // sequential (single-hue) + ["blues", interpolateBlues], + ["greens", interpolateGreens], + ["greys", interpolateGreys], + ["purples", interpolatePurples], + ["reds", interpolateReds], + ["oranges", interpolateOranges], + + // sequential (multi-hue) + ["turbo", interpolateTurbo], + ["viridis", interpolateViridis], + ["magma", interpolateMagma], + ["inferno", interpolateInferno], + ["plasma", interpolatePlasma], + ["cividis", interpolateCividis], + ["cubehelix", interpolateCubehelixDefault], + ["warm", interpolateWarm], + ["cool", interpolateCool], + ["bugn", interpolateBuGn], + ["bupu", interpolateBuPu], + ["gnbu", interpolateGnBu], + ["orrd", interpolateOrRd], + ["pubugn", interpolatePuBuGn], + ["pubu", interpolatePuBu], + ["purd", interpolatePuRd], + ["rdpu", interpolateRdPu], + ["ylgnbu", interpolateYlGnBu], + ["ylgn", interpolateYlGn], + ["ylorbr", interpolateYlOrBr], + ["ylorrd", interpolateYlOrRd], + + // cyclical + ["rainbow", interpolateRainbow], + ["sinebow", interpolateSinebow] +]); + +function quantitativeScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`); + return quantitativeSchemes.get(s); +} + +const divergingSchemes = new Set([ + "brbg", + "prgn", + "piyg", + "puor", + "rdbu", + "rdgy", + "rdylbu", + "rdylgn", + "spectral", + "burd", + "buylrd" +]); + +function isDivergingScheme(scheme) { + return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase()); +} + +const flip = (i) => (t) => i(1 - t); +const unit = [0, 1]; + +const interpolators = new Map([ + // numbers + ["number", interpolateNumber], + + // color spaces + ["rgb", interpolateRgb], + ["hsl", interpolateHsl], + ["hcl", interpolateHcl], + ["lab", interpolateLab] +]); + +function maybeInterpolator(interpolate) { + const i = `${interpolate}`.toLowerCase(); + if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`); + return interpolators.get(i); +} + +function createScaleQ( + key, + scale, + channels, + { + type, + nice, + clamp, + zero, + domain = inferAutoDomain(key, channels), + unknown, + round, + scheme, + interval, + range = registry.get(key) === radius + ? inferRadialRange(channels, domain) + : registry.get(key) === length + ? inferLengthRange(channels, domain) + : registry.get(key) === opacity + ? unit + : undefined, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : type === "cyclical" ? "rainbow" : "turbo") + : round + ? interpolateRound + : interpolateNumber, + reverse: reverse$1 + } +) { + interval = maybeRangeInterval(interval, type); + if (type === "cyclical" || type === "sequential") type = "linear"; // shorthand for color schemes + reverse$1 = !!reverse$1; + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + if (interpolate.length === 1) { + if (reverse$1) { + interpolate = flip(interpolate); + reverse$1 = false; + } + if (range === undefined) { + range = Float64Array.from(domain, (_, i) => i / (domain.length - 1)); + if (range.length === 2) range = unit; // optimize common case of [0, 1] + } + scale.interpolate((range === unit ? constant : interpolatePiecewise)(interpolate)); + } else { + scale.interpolate(interpolate); + } + + // If a zero option is specified, we assume that the domain is numeric, and we + // want to ensure that the domain crosses zero. However, note that the domain + // may be reversed (descending) so we shouldn’t assume that the first value is + // smaller than the last; and also it’s possible that the domain has more than + // two values for a “poly” scale. And lastly be careful not to mutate input! + if (zero) { + const [min, max] = extent(domain); + if (min > 0 || max < 0) { + domain = slice(domain); + if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0; + // [2, 1] or [-2, -1] + else domain[0] = 0; // [1, 2] or [-1, -2] + } + } + + if (reverse$1) domain = reverse(domain); + scale.domain(domain).unknown(unknown); + if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain()); + if (range !== undefined) scale.range(range); + if (clamp) scale.clamp(clamp); + return {type, domain, range, scale, interpolate, interval}; +} + +function maybeNice(nice, type) { + return nice === true ? undefined : typeof nice === "number" ? nice : maybeNiceInterval(nice, type); +} + +function createScaleLinear(key, channels, options) { + return createScaleQ(key, scaleLinear(), channels, options); +} + +function createScaleSqrt(key, channels, options) { + return createScalePow(key, channels, {...options, exponent: 0.5}); +} + +function createScalePow(key, channels, {exponent = 1, ...options}) { + return createScaleQ(key, scalePow().exponent(exponent), channels, {...options, type: "pow"}); +} + +function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) { + return createScaleQ(key, scaleLog().base(base), channels, {...options, domain}); +} + +function createScaleSymlog(key, channels, {constant = 1, ...options}) { + return createScaleQ(key, scaleSymlog().constant(constant), channels, options); +} + +function createScaleQuantile( + key, + channels, + { + range, + quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead + n = quantiles, + scheme = "rdylbu", + domain = inferQuantileDomain(channels), + unknown, + interpolate, + reverse + } +) { + if (range === undefined) { + range = + interpolate !== undefined + ? quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } + if (domain.length > 0) { + domain = scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles(); + } + return createScaleThreshold(key, channels, {domain, range, reverse, unknown}); +} + +function createScaleQuantize( + key, + channels, + { + range, + n = range === undefined ? 5 : (range = [...range]).length, + scheme = "rdylbu", + domain = inferAutoDomain(key, channels), + unknown, + interpolate, + reverse + } +) { + const [min, max] = extent(domain); + let thresholds; + if (range === undefined) { + thresholds = ticks(min, max, n); // approximate number of nice, round thresholds + if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound + if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound + n = thresholds.length + 1; + range = + interpolate !== undefined + ? quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } else { + thresholds = quantize(interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range + if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types + } + if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain + return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown}); +} + +function createScaleThreshold( + key, + channels, + { + domain = [0], // explicit thresholds in ascending order + unknown, + scheme = "rdylbu", + interpolate, + range = interpolate !== undefined + ? quantize(interpolate, domain.length + 1) + : registry.get(key) === color + ? ordinalRange(scheme, domain.length + 1) + : undefined, + reverse: reverse$1 + } +) { + domain = arrayify(domain); + const sign = orderof(domain); // preserve descending domain + if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`); + if (reverse$1) range = reverse(range); // domain ascending, so reverse range + return { + type: "threshold", + scale: scaleThreshold(sign < 0 ? reverse(domain) : domain, range === undefined ? [] : range).unknown(unknown), + domain, + range + }; +} + +function isOrdered(domain, sign) { + for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) { + const s = descending(d, (d = domain[i])); + if (s !== 0 && s !== sign) return false; + } + return true; +} + +function createScaleIdentity() { + return {type: "identity", scale: scaleIdentity()}; +} + +function inferDomain$1(channels, f = finite) { + return channels.length + ? [ + min$2(channels, ({value}) => (value === undefined ? value : min$2(value, f))), + max$1(channels, ({value}) => (value === undefined ? value : max$1(value, f))) + ] + : [0, 1]; +} + +function inferAutoDomain(key, channels) { + const type = registry.get(key); + return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain$1)(channels); +} + +function inferZeroDomain(channels) { + return [0, channels.length ? max$1(channels, ({value}) => (value === undefined ? value : max$1(value, finite))) : 1]; +} + +// We don’t want the upper bound of the radial domain to be zero, as this would +// be degenerate, so we ignore nonpositive values. We also don’t want the +// maximum default radius to exceed 30px. +function inferRadialRange(channels, domain) { + const hint = channels.find(({radius}) => radius !== undefined); + if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins + const h25 = quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : quantile(value, 0.25, positive))); + const range = domain.map((d) => 3 * Math.sqrt(d / h25)); + const k = 30 / max$1(range); + return k < 1 ? range.map((r) => r * k) : range; +} + +// We want a length scale’s domain to go from zero to a positive value, and to +// treat negative lengths if any as inverted vectors of equivalent magnitude. We +// also don’t want the maximum default length to exceed 60px. +function inferLengthRange(channels, domain) { + const h50 = median(channels, ({value}) => (value === undefined ? NaN : median(value, Math.abs))); + const range = domain.map((d) => (12 * d) / h50); + const k = 60 / max$1(range); + return k < 1 ? range.map((r) => r * k) : range; +} + +function inferLogDomain(channels) { + for (const {value} of channels) { + if (value !== undefined) { + for (let v of value) { + if (v > 0) return inferDomain$1(channels, positive); + if (v < 0) return inferDomain$1(channels, negative); + } + } + } + return [1, 10]; +} + +function inferQuantileDomain(channels) { + const domain = []; + for (const {value} of channels) { + if (value === undefined) continue; + for (const v of value) domain.push(v); + } + return domain; +} + +function interpolatePiecewise(interpolate) { + return (i, j) => (t) => interpolate(i + t * (j - i)); +} + +function createScaleD( + key, + scale, + transform, + channels, + { + type, + nice, + clamp, + domain = inferDomain$1(channels), + unknown, + pivot = 0, + scheme, + range, + symmetric = true, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : "rdbu") + : interpolateNumber, + reverse + } +) { + pivot = +pivot; + let [min, max] = domain; + if (descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse); + min = Math.min(min, pivot); + max = Math.max(max, pivot); + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + + // If an explicit range is specified, promote it to a piecewise interpolator. + if (range !== undefined) { + interpolate = + interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : piecewise(interpolate, range); + } + + // Reverse before normalization. + if (reverse) interpolate = flip(interpolate); + + // Normalize the interpolator for symmetric difference around the pivot. + if (symmetric) { + const mid = transform.apply(pivot); + const mindelta = mid - transform.apply(min); + const maxdelta = transform.apply(max) - mid; + if (mindelta < maxdelta) min = transform.invert(mid - maxdelta); + else if (mindelta > maxdelta) max = transform.invert(mid + mindelta); + } + + scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate); + if (clamp) scale.clamp(clamp); + if (nice) scale.nice(nice); + return {type, domain: [min, max], pivot, interpolate, scale}; +} + +function createScaleDiverging(key, channels, options) { + return createScaleD(key, scaleDiverging(), transformIdentity, channels, options); +} + +function createScaleDivergingSqrt(key, channels, options) { + return createScaleDivergingPow(key, channels, {...options, exponent: 0.5}); +} + +function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) { + return createScaleD(key, scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, { + ...options, + type: "diverging-pow" + }); +} + +function createScaleDivergingLog( + key, + channels, + {base = 10, pivot = 1, domain = inferDomain$1(channels, pivot < 0 ? negative : positive), ...options} +) { + return createScaleD(key, scaleDivergingLog().base((base = +base)), transformLog, channels, { + domain, + pivot, + ...options + }); +} + +function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) { + return createScaleD( + key, + scaleDivergingSymlog().constant((constant = +constant)), + transformSymlog(constant), + channels, + options + ); +} + +const transformIdentity = { + apply(x) { + return x; + }, + invert(x) { + return x; + } +}; + +const transformLog = { + apply: Math.log, + invert: Math.exp +}; + +const transformSqrt = { + apply(x) { + return Math.sign(x) * Math.sqrt(Math.abs(x)); + }, + invert(x) { + return Math.sign(x) * (x * x); + } +}; + +function transformPow(exponent) { + return exponent === 0.5 + ? transformSqrt + : { + apply(x) { + return Math.sign(x) * Math.pow(Math.abs(x), exponent); + }, + invert(x) { + return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent); + } + }; +} + +function transformSymlog(constant) { + return { + apply(x) { + return Math.sign(x) * Math.log1p(Math.abs(x / constant)); + }, + invert(x) { + return Math.sign(x) * Math.expm1(Math.abs(x)) * constant; + } + }; +} + +function createScaleT(key, scale, channels, options) { + return createScaleQ(key, scale, channels, options); +} + +function createScaleTime(key, channels, options) { + return createScaleT(key, scaleTime(), channels, options); +} + +function createScaleUtc(key, channels, options) { + return createScaleT(key, scaleUtc(), channels, options); +} + +// This denotes an implicitly ordinal color scale: the scale type was not set, +// but the associated values are strings or booleans. If the associated defined +// values are entirely boolean, the range will default to greys. You can opt out +// of this by setting the type explicitly. +const ordinalImplicit = Symbol("ordinal"); + +function createScaleO(key, scale, channels, {type, interval, domain, range, reverse: reverse$1, hint}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + if (type === "categorical" || type === ordinalImplicit) type = "ordinal"; // shorthand for color schemes + if (reverse$1) domain = reverse(domain); + scale.domain(domain); + if (range !== undefined) { + // If the range is specified as a function, pass it the domain. + if (typeof range === "function") range = range(domain); + scale.range(range); + } + return {type, domain, range, scale, hint, interval}; +} + +function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + let hint; + if (registry.get(key) === symbol) { + hint = inferSymbolHint(channels); + range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol); + } else if (registry.get(key) === color) { + if (range === undefined && (type === "ordinal" || type === ordinalImplicit)) { + range = maybeBooleanRange(domain, scheme); + if (range !== undefined) scheme = undefined; // Don’t re-apply scheme. + } + if (scheme === undefined && range === undefined) { + scheme = type === "ordinal" ? "turbo" : "tableau10"; + } + if (scheme !== undefined) { + if (range !== undefined) { + const interpolate = quantitativeScheme(scheme); + const t0 = range[0], + d = range[1] - range[0]; + range = ({length: n}) => quantize((t) => interpolate(t0 + d * t), n); + } else { + range = ordinalScheme(scheme); + } + } + } + if (unknown === scaleImplicit) { + throw new Error(`implicit unknown on ${key} scale is not supported`); + } + return createScaleO(key, scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint}); +} + +function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) { + return maybeRound(scalePoint().align(align).padding(padding), channels, options, key); +} + +function createScaleBand( + key, + channels, + { + align = 0.5, + padding = 0.1, + paddingInner = padding, + paddingOuter = key === "fx" || key === "fy" ? 0 : padding, + ...options + } +) { + return maybeRound( + scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter), + channels, + options, + key + ); +} + +function maybeRound(scale, channels, options, key) { + let {round} = options; + if (round !== undefined) scale.round((round = !!round)); + scale = createScaleO(key, scale, channels, options); + scale.round = round; // preserve for autoScaleRound + return scale; +} + +function inferDomain(channels, interval, key) { + const values = new InternSet(); + for (const {value, domain} of channels) { + if (domain !== undefined) return domain(); // see channelDomain + if (value === undefined) continue; + for (const v of value) values.add(v); + } + if (interval !== undefined) { + const [min, max] = extent(values).map(interval.floor, interval); + return interval.range(min, interval.offset(max)); + } + if (values.size > 10e3 && registry.get(key) === position) { + throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`); + } + return sort(values, ascendingDefined); +} + +// If all channels provide a consistent hint, propagate it to the scale. +function inferHint(channels, key) { + let value; + for (const {hint} of channels) { + const candidate = hint?.[key]; + if (candidate === undefined) continue; // no hint here + if (value === undefined) value = candidate; + // first hint + else if (value !== candidate) return; // inconsistent hint + } + return value; +} + +function inferSymbolHint(channels) { + return { + fill: inferHint(channels, "fill"), + stroke: inferHint(channels, "stroke") + }; +} + +function inferSymbolRange(hint) { + return isNoneish(hint.fill) ? symbolsStroke : symbolsFill; +} + +function normalizeScale(key, scale, hint) { + return createScale(key, hint === undefined ? undefined : [{hint}], {...scale}); +} + +function createScale(key, channels = [], options = {}) { + const type = inferScaleType(key, channels, options); + + // Warn for common misuses of implicit ordinal scales. We disable this test if + // you specify a scale interval or if you set the domain or range explicitly, + // since setting the domain or range (typically with a cardinality of more than + // two) is another indication that you intended for the scale to be ordinal; we + // also disable it for facet scales since these are always band scales. + if ( + options.type === undefined && + options.domain === undefined && + options.range === undefined && + options.interval == null && + key !== "fx" && + key !== "fy" && + isOrdinalScale({type}) + ) { + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isTemporal)) + warn( + `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isTemporalString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isNumericString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${formatScaleType( + type + )}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + } + + options.type = type; // Mutates input! + + // Once the scale type is known, coerce the associated channel values and any + // explicitly-specified domain to the expected type. + switch (type) { + case "diverging": + case "diverging-sqrt": + case "diverging-pow": + case "diverging-log": + case "diverging-symlog": + case "cyclical": + case "sequential": + case "linear": + case "sqrt": + case "threshold": + case "quantile": + case "pow": + case "log": + case "symlog": + options = coerceType(channels, options, coerceNumbers); + break; + case "identity": + switch (registry.get(key)) { + case position: + options = coerceType(channels, options, coerceNumbers); + break; + case symbol: + options = coerceType(channels, options, coerceSymbols); + break; + } + break; + case "utc": + case "time": + options = coerceType(channels, options, coerceDates); + break; + } + + switch (type) { + case "diverging": + return createScaleDiverging(key, channels, options); + case "diverging-sqrt": + return createScaleDivergingSqrt(key, channels, options); + case "diverging-pow": + return createScaleDivergingPow(key, channels, options); + case "diverging-log": + return createScaleDivergingLog(key, channels, options); + case "diverging-symlog": + return createScaleDivergingSymlog(key, channels, options); + case "categorical": + case "ordinal": + case ordinalImplicit: + return createScaleOrdinal(key, channels, options); + case "cyclical": + case "sequential": + case "linear": + return createScaleLinear(key, channels, options); + case "sqrt": + return createScaleSqrt(key, channels, options); + case "threshold": + return createScaleThreshold(key, channels, options); + case "quantile": + return createScaleQuantile(key, channels, options); + case "quantize": + return createScaleQuantize(key, channels, options); + case "pow": + return createScalePow(key, channels, options); + case "log": + return createScaleLog(key, channels, options); + case "symlog": + return createScaleSymlog(key, channels, options); + case "utc": + return createScaleUtc(key, channels, options); + case "time": + return createScaleTime(key, channels, options); + case "point": + return createScalePoint(key, channels, options); + case "band": + return createScaleBand(key, channels, options); + case "identity": + return registry.get(key) === position ? createScaleIdentity() : {type: "identity"}; + case undefined: + return; + default: + throw new Error(`unknown scale type: ${type}`); + } +} + +function formatScaleType(type) { + return typeof type === "symbol" ? type.description : type; +} + +// A special type symbol when the x and y scales are replaced with a projection. +const typeProjection = {toString: () => "projection"}; + +function inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) { + // The facet scales are always band scales; this cannot be changed. + if (key === "fx" || key === "fy") return "band"; + + // If a projection is specified, the x- and y-scales are disabled; these + // channels will be projected rather than scaled. (But still check that none + // of the associated channels are incompatible with a projection.) + if ((key === "x" || key === "y") && projection != null) type = typeProjection; + + // If a channel dictates a scale type, make sure that it is consistent with + // the user-specified scale type (if any) and all other channels. For example, + // barY requires x to be a band scale and disallows any other scale type. + for (const {type: t} of channels) { + if (t === undefined) continue; + else if (type === undefined) type = t; + else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`); + } + + // If the scale, a channel, or user specified a (consistent) type, return it. + if (type === typeProjection) return; + if (type !== undefined) return type; + + // If there’s no data (and no type) associated with this scale, don’t create a scale. + if (domain === undefined && !channels.some(({value}) => value !== undefined)) return; + + // Some scales have default types. + const kind = registry.get(key); + if (kind === radius) return "sqrt"; + if (kind === opacity || kind === length) return "linear"; + if (kind === symbol) return "ordinal"; + + // If the domain or range has more than two values, assume it’s ordinal. You + // can still use a “piecewise” (or “polylinear”) scale, but you must set the + // type explicitly. + if ((domain || range || []).length > 2) return asOrdinalType(kind); + + // Otherwise, infer the scale type from the data! Prefer the domain, if + // present, over channels. (The domain and channels should be consistently + // typed, and the domain is more explicit and typically much smaller.) We only + // check the first defined value for expedience and simplicity; we expect + // that the types are consistent. + if (domain !== undefined) { + if (isOrdinal(domain)) return asOrdinalType(kind); + if (isTemporal(domain)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; + } + + // If any channel is ordinal or temporal, it takes priority. + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isOrdinal)) return asOrdinalType(kind); + if (values.some(isTemporal)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; +} + +// Positional scales default to a point scale instead of an ordinal scale. +function asOrdinalType(kind) { + switch (kind) { + case position: + return "point"; + case color: + return ordinalImplicit; + default: + return "ordinal"; + } +} + +function isOrdinalScale({type}) { + return type === "ordinal" || type === "point" || type === "band" || type === ordinalImplicit; +} + +function isThresholdScale({type}) { + return type === "threshold"; +} + +// Mutates channel.value! +function coerceType(channels, {domain, ...options}, coerceValues) { + for (const c of channels) { + if (c.value !== undefined) { + c.value = coerceValues(c.value); + } + } + return { + domain: domain === undefined ? domain : coerceValues(domain), + ...options + }; +} + +function coerceSymbols(values) { + return map(values, maybeSymbol); +} + +function memoize1(compute) { + let cacheValue, cacheKeys; + return (...keys) => { + if (cacheKeys?.length !== keys.length || cacheKeys.some((k, i) => k !== keys[i])) { + cacheKeys = keys; + cacheValue = compute(...keys); + } + return cacheValue; + }; +} + +const numberFormat = memoize1((locale) => { + return new Intl.NumberFormat(locale); +}); + +function formatNumber(locale = "en-US") { + const format = numberFormat(locale); + return (i) => (i != null && !isNaN(i) ? format.format(i) : undefined); +} + +function formatIsoDate(date) { + return format(date, "Invalid Date"); +} + +function formatAuto(locale = "en-US") { + const number = formatNumber(locale); + return (v) => (v instanceof Date ? formatIsoDate : typeof v === "number" ? number : string)(v); +} + +// TODO When Plot supports a top-level locale option, this should be removed +// because it lacks context to know which locale to use; formatAuto should be +// used instead whenever possible. +formatAuto(); + +function impliedString(value, impliedValue) { + if ((value = string(value)) !== impliedValue) return value; +} + +// https://www.w3.org/TR/CSS21/grammar.html +const validClassName = + /^-?([_a-z]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])([_a-z0-9-]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])*$/i; + +function maybeClassName(name) { + // The default should be changed whenever the default styles are changed, so + // as to avoid conflict when multiple versions of Plot are on the page. + if (name === undefined) return "plot-d6a7b5"; + name = `${name}`; + if (!validClassName.test(name)) throw new Error(`invalid class name: ${name}`); + return name; +} + +function applyInlineStyles(selection, style) { + if (typeof style === "string") { + selection.property("style", style); + } else if (style != null) { + for (const element of selection) { + Object.assign(element.style, style); + } + } +} + +function inferFontVariant(scale) { + return isOrdinalScale(scale) && scale.interval === undefined ? undefined : "tabular-nums"; +} + +// D3 doesn’t provide a tick format for ordinal scales; we want shorthand when +// an ordinal domain is numbers or dates, and we want null to mean the empty +// string, not the default identity format. TODO Remove this in favor of the +// axis mark’s inferTickFormat. +function maybeAutoTickFormat(tickFormat, domain) { + return tickFormat === undefined + ? isTemporal(domain) + ? formatIsoDate + : string + : typeof tickFormat === "function" + ? tickFormat + : (typeof tickFormat === "string" ? (isTemporal(domain) ? utcFormat : format$1) : constant)(tickFormat); +} + +function legendRamp(color, options) { + let { + label = color.label, + tickSize = 6, + width = 240, + height = 44 + tickSize, + marginTop = 18, + marginRight = 0, + marginBottom = 16 + tickSize, + marginLeft = 0, + style, + ticks = (width - marginLeft - marginRight) / 64, + tickFormat, + fontVariant = inferFontVariant(color), + round = true, + opacity, + className + } = options; + const context = createContext(options); + className = maybeClassName(className); + opacity = maybeNumberChannel(opacity)[1]; + if (tickFormat === null) tickFormat = () => null; + + const svg = create("svg", context) + .attr("class", `${className}-ramp`) + .attr("font-family", "system-ui, sans-serif") + .attr("font-size", 10) + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .call((svg) => + // Warning: if you edit this, change defaultClassName. + svg.append("style").text( + `.${className}-ramp { + display: block; + background: white; + height: auto; + height: intrinsic; + max-width: 100%; + overflow: visible; +} +.${className}-ramp text { + white-space: pre; +}` + ) + ) + .call(applyInlineStyles, style); + + let tickAdjust = (g) => g.selectAll(".tick line").attr("y1", marginTop + marginBottom - height); + + let x; + + // Some D3 scales use scale.interpolate, some scale.interpolator, and some + // scale.round; this normalizes the API so it works with all scale types. + const applyRange = round ? (x, range) => x.rangeRound(range) : (x, range) => x.range(range); + + const {type, domain, range, interpolate, scale, pivot} = color; + + // Continuous + if (interpolate) { + // Often interpolate is a “fixed” interpolator on the [0, 1] interval, as + // with a built-in color scheme, but sometimes it is a function that takes + // two arguments and is used in conjunction with the range. + const interpolator = + range === undefined + ? interpolate + : piecewise(interpolate.length === 1 ? interpolatePiecewise(interpolate) : interpolate, range); + + // Construct a D3 scale of the same type, but with a range that evenly + // divides the horizontal extent of the legend. (In the common case, the + // domain.length is two, and so the range is simply the extent.) For a + // diverging scale, we need an extra point in the range for the pivot such + // that the pivot is always drawn in the middle. + x = applyRange( + scale.copy(), + quantize( + interpolateNumber(marginLeft, width - marginRight), + Math.min(domain.length + (pivot !== undefined), range === undefined ? Infinity : range.length) + ) + ); + + // Construct a 256×1 canvas, filling each pixel using the interpolator. + const n = 256; + const canvas = context.document.createElement("canvas"); + canvas.width = n; + canvas.height = 1; + const context2 = canvas.getContext("2d"); + for (let i = 0, j = n - 1; i < n; ++i) { + context2.fillStyle = interpolator(i / j); + context2.fillRect(i, 0, 1, 1); + } + + svg + .append("image") + .attr("opacity", opacity) + .attr("x", marginLeft) + .attr("y", marginTop) + .attr("width", width - marginLeft - marginRight) + .attr("height", height - marginTop - marginBottom) + .attr("preserveAspectRatio", "none") + .attr("xlink:href", canvas.toDataURL()); + } + + // Threshold + else if (type === "threshold") { + const thresholds = domain; + + const thresholdFormat = + tickFormat === undefined ? (d) => d : typeof tickFormat === "string" ? format$1(tickFormat) : tickFormat; + + // Construct a linear scale with evenly-spaced ticks for each of the + // thresholds; the domain extends one beyond the threshold extent. + x = applyRange(scaleLinear().domain([-1, range.length - 1]), [marginLeft, width - marginRight]); + + svg + .append("g") + .attr("fill-opacity", opacity) + .selectAll() + .data(range) + .enter() + .append("rect") + .attr("x", (d, i) => x(i - 1)) + .attr("y", marginTop) + .attr("width", (d, i) => x(i) - x(i - 1)) + .attr("height", height - marginTop - marginBottom) + .attr("fill", (d) => d); + + ticks = map(thresholds, (_, i) => i); + tickFormat = (i) => thresholdFormat(thresholds[i], i); + } + + // Ordinal (hopefully!) + else { + x = applyRange(scaleBand().domain(domain), [marginLeft, width - marginRight]); + + svg + .append("g") + .attr("fill-opacity", opacity) + .selectAll() + .data(domain) + .enter() + .append("rect") + .attr("x", x) + .attr("y", marginTop) + .attr("width", Math.max(0, x.bandwidth() - 1)) + .attr("height", height - marginTop - marginBottom) + .attr("fill", scale); + + tickAdjust = () => {}; + } + + svg + .append("g") + .attr("transform", `translate(0,${height - marginBottom})`) + .call( + axisBottom(x) + .ticks(Array.isArray(ticks) ? null : ticks, typeof tickFormat === "string" ? tickFormat : undefined) + .tickFormat(typeof tickFormat === "function" ? tickFormat : undefined) + .tickSize(tickSize) + .tickValues(Array.isArray(ticks) ? ticks : null) + ) + .attr("font-size", null) + .attr("font-family", null) + .attr("font-variant", impliedString(fontVariant, "normal")) + .call(tickAdjust) + .call((g) => g.select(".domain").remove()); + + if (label !== undefined) { + svg + .append("text") + .attr("x", marginLeft) + .attr("y", marginTop - 6) + .attr("fill", "currentColor") // TODO move to stylesheet? + .attr("font-weight", "bold") + .text(label); + } + + return svg.node(); +} + +function maybeScale(scale, key) { + if (key == null) return key; + const s = scale(key); + if (!s) throw new Error(`scale not found: ${key}`); + return s; +} + +function legendSwatches(color, {opacity, ...options} = {}) { + if (!isOrdinalScale(color) && !isThresholdScale(color)) + throw new Error(`swatches legend requires ordinal or threshold color scale (not ${color.type})`); + return legendItems(color, options, (selection, scale, width, height) => + selection + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("fill", scale.scale) + .attr("fill-opacity", maybeNumberChannel(opacity)[1]) + .append("rect") + .attr("width", "100%") + .attr("height", "100%") + ); +} + +function legendSymbols( + symbol, + { + fill = symbol.hint?.fill !== undefined ? symbol.hint.fill : "none", + fillOpacity = 1, + stroke = symbol.hint?.stroke !== undefined ? symbol.hint.stroke : isNoneish(fill) ? "currentColor" : "none", + strokeOpacity = 1, + strokeWidth = 1.5, + r = 4.5, + ...options + } = {}, + scale +) { + const [vf, cf] = maybeColorChannel(fill); + const [vs, cs] = maybeColorChannel(stroke); + const sf = maybeScale(scale, vf); + const ss = maybeScale(scale, vs); + const size = r * r * Math.PI; + fillOpacity = maybeNumberChannel(fillOpacity)[1]; + strokeOpacity = maybeNumberChannel(strokeOpacity)[1]; + strokeWidth = maybeNumberChannel(strokeWidth)[1]; + return legendItems(symbol, options, (selection, scale, width, height) => + selection + .append("svg") + .attr("viewBox", "-8 -8 16 16") + .attr("width", width) + .attr("height", height) + .attr("fill", vf === "color" ? (d) => sf.scale(d) : cf) + .attr("fill-opacity", fillOpacity) + .attr("stroke", vs === "color" ? (d) => ss.scale(d) : cs) + .attr("stroke-opacity", strokeOpacity) + .attr("stroke-width", strokeWidth) + .append("path") + .attr("d", (d) => { + const p = pathRound(); + symbol.scale(d).draw(p, size); + return p; + }) + ); +} + +function legendItems(scale, options = {}, swatch) { + let { + columns, + tickFormat, + fontVariant = inferFontVariant(scale), + // TODO label, + swatchSize = 15, + swatchWidth = swatchSize, + swatchHeight = swatchSize, + marginLeft = 0, + className, + style, + width + } = options; + const context = createContext(options); + className = maybeClassName(className); + tickFormat = maybeAutoTickFormat(tickFormat, scale.domain); + + const swatches = create("div", context).attr( + "class", + `${className}-swatches ${className}-swatches-${columns != null ? "columns" : "wrap"}` + ); + + let extraStyle; + + if (columns != null) { + extraStyle = `.${className}-swatches-columns .${className}-swatch { + display: flex; + align-items: center; + break-inside: avoid; + padding-bottom: 1px; +} +.${className}-swatches-columns .${className}-swatch::before { + flex-shrink: 0; +} +.${className}-swatches-columns .${className}-swatch-label { + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +}`; + + swatches + .style("columns", columns) + .selectAll() + .data(scale.domain) + .enter() + .append("div") + .attr("class", `${className}-swatch`) + .call(swatch, scale, swatchWidth, swatchHeight) + .call((item) => + item.append("div").attr("class", `${className}-swatch-label`).attr("title", tickFormat).text(tickFormat) + ); + } else { + extraStyle = `.${className}-swatches-wrap { + display: flex; + align-items: center; + min-height: 33px; + flex-wrap: wrap; +} +.${className}-swatches-wrap .${className}-swatch { + display: inline-flex; + align-items: center; + margin-right: 1em; +}`; + + swatches + .selectAll() + .data(scale.domain) + .enter() + .append("span") + .attr("class", `${className}-swatch`) + .call(swatch, scale, swatchWidth, swatchHeight) + .append(function () { + return this.ownerDocument.createTextNode(tickFormat.apply(this, arguments)); + }); + } + + return swatches + .call((div) => + div.insert("style", "*").text( + `.${className}-swatches { + font-family: system-ui, sans-serif; + font-size: 10px; + margin-bottom: 0.5em; +} +.${className}-swatch > svg { + margin-right: 0.5em; + overflow: visible; +} +${extraStyle}` + ) + ) + .style("margin-left", marginLeft ? `${+marginLeft}px` : null) + .style("width", width === undefined ? null : `${+width}px`) + .style("font-variant", impliedString(fontVariant, "normal")) + .call(applyInlineStyles, style) + .node(); +} + +const legendRegistry = new Map([ + ["symbol", legendSymbols], + ["color", legendColor], + ["opacity", legendOpacity] +]); + +function legend(options = {}) { + for (const [key, value] of legendRegistry) { + const scale = options[key]; + if (isScaleOptions(scale)) { + // e.g., ignore {color: "red"} + const context = createContext(options); + let hint; + // For symbol legends, pass a hint to the symbol scale. + if (key === "symbol") { + const {fill, stroke = fill === undefined && isScaleOptions(options.color) ? "color" : undefined} = options; + hint = {fill, stroke}; + } + return value(normalizeScale(key, scale, hint), legendOptions(context, scale, options), (key) => + isScaleOptions(options[key]) ? normalizeScale(key, options[key]) : null + ); + } + } + throw new Error("unknown legend type; no scale found"); +} + +function legendOptions({className, ...context}, {label, ticks, tickFormat} = {}, options) { + return inherit(options, {className, ...context}, {label, ticks, tickFormat}); +} + +function legendColor(color, {legend = true, ...options}) { + if (legend === true) legend = color.type === "ordinal" ? "swatches" : "ramp"; + if (color.domain === undefined) return; + switch (`${legend}`.toLowerCase()) { + case "swatches": + return legendSwatches(color, options); + case "ramp": + return legendRamp(color, options); + default: + throw new Error(`unknown legend type: ${legend}`); + } +} + +function legendOpacity({type, interpolate, ...scale}, {legend = true, color = rgb(0, 0, 0), ...options}) { + if (!interpolate) throw new Error(`${type} opacity scales are not supported`); + if (legend === true) legend = "ramp"; + if (`${legend}`.toLowerCase() !== "ramp") throw new Error(`${legend} opacity legends are not supported`); + return legendColor({type, ...scale, interpolate: interpolateOpacity(color)}, {legend, ...options}); +} + +function interpolateOpacity(color) { + const {r, g, b} = rgb(color) || rgb(0, 0, 0); // treat invalid color as black + return (t) => `rgba(${r},${g},${b},${t})`; +} + +var DEFAULT_SELECTOR = '#ch-plugin-legend'; +var defaultOptions = { + // Whether to display the legend + enabled: true, + itemSelector: null, + label: null, + width: 130 +}; +var Legend = /*#__PURE__*/function () { + function Legend(calendar) { + _classCallCheck(this, Legend); + this.name = 'Legend'; + this.calendar = calendar; + this.root = null; + this.shown = false; + this.options = defaultOptions; + } + _createClass(Legend, [{ + key: "setup", + value: function setup(pluginOptions) { + this.options = Object.assign(Object.assign({}, defaultOptions), pluginOptions); + } + }, { + key: "paint", + value: function paint() { + var scaleOptions = this.calendar.options.options.scale; + var _this$options = this.options, + enabled = _this$options.enabled, + itemSelector = _this$options.itemSelector; + if (!enabled || itemSelector && select$1(itemSelector).empty()) { + return this.destroy(); + } + this.shown = true; + this.root = select$1(itemSelector || this.calendar.options.options.itemSelector); + if (this.root.select(DEFAULT_SELECTOR).empty()) { + this.root = this.root.append('div').attr('id', DEFAULT_SELECTOR.slice(1)); + } else { + this.root = this.root.select(DEFAULT_SELECTOR); + } + // @ts-ignore + var node = legend(Object.assign(Object.assign({}, scaleOptions), this.options)); + this.root.selectAll('*').remove(); + this.root.append(function () { + return node; + }); + return Promise.resolve(); + } + }, { + key: "destroy", + value: function destroy() { + if (this.root !== null) { + this.root.remove(); + this.root = null; + } + return Promise.resolve(); + } + }]); + return Legend; +}(); + +export { Legend as default }; diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Legend.js b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.js new file mode 100644 index 0000000..58b4a11 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.js @@ -0,0 +1,4526 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('d3-selection'), require('d3')) : + typeof define === 'function' && define.amd ? define(['d3-selection', 'd3'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Legend = factory(global.d3, global.d3)); +})(this, (function (d3Selection, d3) { 'use strict'; + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; + } + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); + } + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); + } + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + var fails$b = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } + }; + + var fails$a = fails$b; + + // Detect IE8's incomplete defineProperty implementation + var descriptors = !fails$a(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; + }); + + var fails$9 = fails$b; + + var functionBindNative = !fails$9(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); + }); + + var NATIVE_BIND$3 = functionBindNative; + + var FunctionPrototype$3 = Function.prototype; + var call$d = FunctionPrototype$3.call; + var uncurryThisWithBind = NATIVE_BIND$3 && FunctionPrototype$3.bind.bind(call$d, call$d); + + var functionUncurryThis = NATIVE_BIND$3 ? uncurryThisWithBind : function (fn) { + return function () { + return call$d.apply(fn, arguments); + }; + }; + + // we can't use just `it == null` since of `document.all` special case + // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec + var isNullOrUndefined$4 = function (it) { + return it === null || it === undefined; + }; + + var isNullOrUndefined$3 = isNullOrUndefined$4; + + var $TypeError$c = TypeError; + + // `RequireObjectCoercible` abstract operation + // https://tc39.es/ecma262/#sec-requireobjectcoercible + var requireObjectCoercible$2 = function (it) { + if (isNullOrUndefined$3(it)) throw new $TypeError$c("Can't call method on " + it); + return it; + }; + + var requireObjectCoercible$1 = requireObjectCoercible$2; + + var $Object$3 = Object; + + // `ToObject` abstract operation + // https://tc39.es/ecma262/#sec-toobject + var toObject$2 = function (argument) { + return $Object$3(requireObjectCoercible$1(argument)); + }; + + var uncurryThis$f = functionUncurryThis; + var toObject$1 = toObject$2; + + var hasOwnProperty = uncurryThis$f({}.hasOwnProperty); + + // `HasOwnProperty` abstract operation + // https://tc39.es/ecma262/#sec-hasownproperty + // eslint-disable-next-line es/no-object-hasown -- safe + var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject$1(it), key); + }; + + var DESCRIPTORS$9 = descriptors; + var hasOwn$8 = hasOwnProperty_1; + + var FunctionPrototype$2 = Function.prototype; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getDescriptor = DESCRIPTORS$9 && Object.getOwnPropertyDescriptor; + + var EXISTS$1 = hasOwn$8(FunctionPrototype$2, 'name'); + // additional protection from minified / mangled / dropped function names + var PROPER = EXISTS$1 && (function something() { /* empty */ }).name === 'something'; + var CONFIGURABLE$1 = EXISTS$1 && (!DESCRIPTORS$9 || (DESCRIPTORS$9 && getDescriptor(FunctionPrototype$2, 'name').configurable)); + + var functionName = { + EXISTS: EXISTS$1, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE$1 + }; + + var makeBuiltIn$3 = {exports: {}}; + + var documentAll$2 = typeof document == 'object' && document.all; + + // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot + // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing + var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined; + + var documentAll_1 = { + all: documentAll$2, + IS_HTMLDDA: IS_HTMLDDA + }; + + var $documentAll$1 = documentAll_1; + + var documentAll$1 = $documentAll$1.all; + + // `IsCallable` abstract operation + // https://tc39.es/ecma262/#sec-iscallable + var isCallable$h = $documentAll$1.IS_HTMLDDA ? function (argument) { + return typeof argument == 'function' || argument === documentAll$1; + } : function (argument) { + return typeof argument == 'function'; + }; + + var check = function (it) { + return it && it.Math === Math && it; + }; + + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global$h = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + + var global$g = global$h; + + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$4 = Object.defineProperty; + + var defineGlobalProperty$3 = function (key, value) { + try { + defineProperty$4(global$g, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$g[key] = value; + } return value; + }; + + var global$f = global$h; + var defineGlobalProperty$2 = defineGlobalProperty$3; + + var SHARED = '__core-js_shared__'; + var store$3 = global$f[SHARED] || defineGlobalProperty$2(SHARED, {}); + + var sharedStore = store$3; + + var uncurryThis$e = functionUncurryThis; + var isCallable$g = isCallable$h; + var store$2 = sharedStore; + + var functionToString$1 = uncurryThis$e(Function.toString); + + // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper + if (!isCallable$g(store$2.inspectSource)) { + store$2.inspectSource = function (it) { + return functionToString$1(it); + }; + } + + var inspectSource$3 = store$2.inspectSource; + + var global$e = global$h; + var isCallable$f = isCallable$h; + + var WeakMap$1 = global$e.WeakMap; + + var weakMapBasicDetection = isCallable$f(WeakMap$1) && /native code/.test(String(WeakMap$1)); + + var isCallable$e = isCallable$h; + var $documentAll = documentAll_1; + + var documentAll = $documentAll.all; + + var isObject$8 = $documentAll.IS_HTMLDDA ? function (it) { + return typeof it == 'object' ? it !== null : isCallable$e(it) || it === documentAll; + } : function (it) { + return typeof it == 'object' ? it !== null : isCallable$e(it); + }; + + var objectDefineProperty = {}; + + var global$d = global$h; + var isObject$7 = isObject$8; + + var document$3 = global$d.document; + // typeof document.createElement is 'object' in old IE + var EXISTS = isObject$7(document$3) && isObject$7(document$3.createElement); + + var documentCreateElement = function (it) { + return EXISTS ? document$3.createElement(it) : {}; + }; + + var DESCRIPTORS$8 = descriptors; + var fails$8 = fails$b; + var createElement$1 = documentCreateElement; + + // Thanks to IE8 for its funny defineProperty + var ie8DomDefine = !DESCRIPTORS$8 && !fails$8(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { + get: function () { return 7; } + }).a !== 7; + }); + + var DESCRIPTORS$7 = descriptors; + var fails$7 = fails$b; + + // V8 ~ Chrome 36- + // https://bugs.chromium.org/p/v8/issues/detail?id=3334 + var v8PrototypeDefineBug = DESCRIPTORS$7 && fails$7(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; + }); + + var isObject$6 = isObject$8; + + var $String$4 = String; + var $TypeError$b = TypeError; + + // `Assert: Type(argument) is Object` + var anObject$8 = function (argument) { + if (isObject$6(argument)) return argument; + throw new $TypeError$b($String$4(argument) + ' is not an object'); + }; + + var NATIVE_BIND$2 = functionBindNative; + + var call$c = Function.prototype.call; + + var functionCall = NATIVE_BIND$2 ? call$c.bind(call$c) : function () { + return call$c.apply(call$c, arguments); + }; + + var global$c = global$h; + var isCallable$d = isCallable$h; + + var aFunction = function (argument) { + return isCallable$d(argument) ? argument : undefined; + }; + + var getBuiltIn$7 = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$c[namespace]) : global$c[namespace] && global$c[namespace][method]; + }; + + var uncurryThis$d = functionUncurryThis; + + var objectIsPrototypeOf = uncurryThis$d({}.isPrototypeOf); + + var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || ''; + + var global$b = global$h; + var userAgent$3 = engineUserAgent; + + var process$3 = global$b.process; + var Deno$1 = global$b.Deno; + var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version; + var v8 = versions && versions.v8; + var match, version; + + if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); + } + + // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` + // so check `userAgent` even if `.v8` exists, but 0 + if (!version && userAgent$3) { + match = userAgent$3.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$3.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } + } + + var engineV8Version = version; + + /* eslint-disable es/no-symbol -- required for testing */ + var V8_VERSION$1 = engineV8Version; + var fails$6 = fails$b; + var global$a = global$h; + + var $String$3 = global$a.String; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing + var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$6(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String$3(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$1 && V8_VERSION$1 < 41; + }); + + /* eslint-disable es/no-symbol -- required for testing */ + var NATIVE_SYMBOL$1 = symbolConstructorDetection; + + var useSymbolAsUid = NATIVE_SYMBOL$1 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + + var getBuiltIn$6 = getBuiltIn$7; + var isCallable$c = isCallable$h; + var isPrototypeOf$2 = objectIsPrototypeOf; + var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + + var $Object$2 = Object; + + var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) { + return typeof it == 'symbol'; + } : function (it) { + var $Symbol = getBuiltIn$6('Symbol'); + return isCallable$c($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$2(it)); + }; + + var $String$2 = String; + + var tryToString$4 = function (argument) { + try { + return $String$2(argument); + } catch (error) { + return 'Object'; + } + }; + + var isCallable$b = isCallable$h; + var tryToString$3 = tryToString$4; + + var $TypeError$a = TypeError; + + // `Assert: IsCallable(argument) is true` + var aCallable$8 = function (argument) { + if (isCallable$b(argument)) return argument; + throw new $TypeError$a(tryToString$3(argument) + ' is not a function'); + }; + + var aCallable$7 = aCallable$8; + var isNullOrUndefined$2 = isNullOrUndefined$4; + + // `GetMethod` abstract operation + // https://tc39.es/ecma262/#sec-getmethod + var getMethod$3 = function (V, P) { + var func = V[P]; + return isNullOrUndefined$2(func) ? undefined : aCallable$7(func); + }; + + var call$b = functionCall; + var isCallable$a = isCallable$h; + var isObject$5 = isObject$8; + + var $TypeError$9 = TypeError; + + // `OrdinaryToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-ordinarytoprimitive + var ordinaryToPrimitive$1 = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable$a(fn = input.toString) && !isObject$5(val = call$b(fn, input))) return val; + if (isCallable$a(fn = input.valueOf) && !isObject$5(val = call$b(fn, input))) return val; + if (pref !== 'string' && isCallable$a(fn = input.toString) && !isObject$5(val = call$b(fn, input))) return val; + throw new $TypeError$9("Can't convert object to primitive value"); + }; + + var shared$3 = {exports: {}}; + + var store$1 = sharedStore; + + (shared$3.exports = function (key, value) { + return store$1[key] || (store$1[key] = value !== undefined ? value : {}); + })('versions', []).push({ + version: '3.34.0', + mode: 'global', + copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE', + source: 'https://github.com/zloirock/core-js' + }); + + var sharedExports = shared$3.exports; + + var uncurryThis$c = functionUncurryThis; + + var id = 0; + var postfix = Math.random(); + var toString$2 = uncurryThis$c(1.0.toString); + + var uid$2 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$2(++id + postfix, 36); + }; + + var global$9 = global$h; + var shared$2 = sharedExports; + var hasOwn$7 = hasOwnProperty_1; + var uid$1 = uid$2; + var NATIVE_SYMBOL = symbolConstructorDetection; + var USE_SYMBOL_AS_UID = useSymbolAsUid; + + var Symbol$1 = global$9.Symbol; + var WellKnownSymbolsStore = shared$2('wks'); + var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$1; + + var wellKnownSymbol$a = function (name) { + if (!hasOwn$7(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$7(Symbol$1, name) + ? Symbol$1[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; + }; + + var call$a = functionCall; + var isObject$4 = isObject$8; + var isSymbol$1 = isSymbol$2; + var getMethod$2 = getMethod$3; + var ordinaryToPrimitive = ordinaryToPrimitive$1; + var wellKnownSymbol$9 = wellKnownSymbol$a; + + var $TypeError$8 = TypeError; + var TO_PRIMITIVE = wellKnownSymbol$9('toPrimitive'); + + // `ToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-toprimitive + var toPrimitive$1 = function (input, pref) { + if (!isObject$4(input) || isSymbol$1(input)) return input; + var exoticToPrim = getMethod$2(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$a(exoticToPrim, input, pref); + if (!isObject$4(result) || isSymbol$1(result)) return result; + throw new $TypeError$8("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); + }; + + var toPrimitive = toPrimitive$1; + var isSymbol = isSymbol$2; + + // `ToPropertyKey` abstract operation + // https://tc39.es/ecma262/#sec-topropertykey + var toPropertyKey$2 = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; + }; + + var DESCRIPTORS$6 = descriptors; + var IE8_DOM_DEFINE$1 = ie8DomDefine; + var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; + var anObject$7 = anObject$8; + var toPropertyKey$1 = toPropertyKey$2; + + var $TypeError$7 = TypeError; + // eslint-disable-next-line es/no-object-defineproperty -- safe + var $defineProperty = Object.defineProperty; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; + var ENUMERABLE = 'enumerable'; + var CONFIGURABLE = 'configurable'; + var WRITABLE = 'writable'; + + // `Object.defineProperty` method + // https://tc39.es/ecma262/#sec-object.defineproperty + objectDefineProperty.f = DESCRIPTORS$6 ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) { + anObject$7(O); + P = toPropertyKey$1(P); + anObject$7(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor$1(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); + } : $defineProperty : function defineProperty(O, P, Attributes) { + anObject$7(O); + P = toPropertyKey$1(P); + anObject$7(Attributes); + if (IE8_DOM_DEFINE$1) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$7('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; + }; + + var createPropertyDescriptor$2 = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; + }; + + var DESCRIPTORS$5 = descriptors; + var definePropertyModule$2 = objectDefineProperty; + var createPropertyDescriptor$1 = createPropertyDescriptor$2; + + var createNonEnumerableProperty$2 = DESCRIPTORS$5 ? function (object, key, value) { + return definePropertyModule$2.f(object, key, createPropertyDescriptor$1(1, value)); + } : function (object, key, value) { + object[key] = value; + return object; + }; + + var shared$1 = sharedExports; + var uid = uid$2; + + var keys = shared$1('keys'); + + var sharedKey$1 = function (key) { + return keys[key] || (keys[key] = uid(key)); + }; + + var hiddenKeys$3 = {}; + + var NATIVE_WEAK_MAP = weakMapBasicDetection; + var global$8 = global$h; + var isObject$3 = isObject$8; + var createNonEnumerableProperty$1 = createNonEnumerableProperty$2; + var hasOwn$6 = hasOwnProperty_1; + var shared = sharedStore; + var sharedKey = sharedKey$1; + var hiddenKeys$2 = hiddenKeys$3; + + var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; + var TypeError$2 = global$8.TypeError; + var WeakMap = global$8.WeakMap; + var set$1, get, has; + + var enforce = function (it) { + return has(it) ? get(it) : set$1(it, {}); + }; + + var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject$3(it) || (state = get(it)).type !== TYPE) { + throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; + }; + + if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set$1 = function (it, metadata) { + if (store.has(it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get = function (it) { + return store.get(it) || {}; + }; + has = function (it) { + return store.has(it); + }; + } else { + var STATE = sharedKey('state'); + hiddenKeys$2[STATE] = true; + set$1 = function (it, metadata) { + if (hasOwn$6(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty$1(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn$6(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn$6(it, STATE); + }; + } + + var internalState = { + set: set$1, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor + }; + + var uncurryThis$b = functionUncurryThis; + var fails$5 = fails$b; + var isCallable$9 = isCallable$h; + var hasOwn$5 = hasOwnProperty_1; + var DESCRIPTORS$4 = descriptors; + var CONFIGURABLE_FUNCTION_NAME = functionName.CONFIGURABLE; + var inspectSource$2 = inspectSource$3; + var InternalStateModule$1 = internalState; + + var enforceInternalState = InternalStateModule$1.enforce; + var getInternalState = InternalStateModule$1.get; + var $String$1 = String; + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$3 = Object.defineProperty; + var stringSlice$1 = uncurryThis$b(''.slice); + var replace = uncurryThis$b(''.replace); + var join = uncurryThis$b([].join); + + var CONFIGURABLE_LENGTH = DESCRIPTORS$4 && !fails$5(function () { + return defineProperty$3(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; + }); + + var TEMPLATE = String(String).split('String'); + + var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) { + if (stringSlice$1($String$1(name), 0, 7) === 'Symbol(') { + name = '[' + replace($String$1(name), /^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn$5(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) { + if (DESCRIPTORS$4) defineProperty$3(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn$5(options, 'arity') && value.length !== options.arity) { + defineProperty$3(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn$5(options, 'constructor') && options.constructor) { + if (DESCRIPTORS$4) defineProperty$3(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn$5(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; + }; + + // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative + // eslint-disable-next-line no-extend-native -- required + Function.prototype.toString = makeBuiltIn$2(function toString() { + return isCallable$9(this) && getInternalState(this).source || inspectSource$2(this); + }, 'toString'); + + var makeBuiltInExports = makeBuiltIn$3.exports; + + var makeBuiltIn$1 = makeBuiltInExports; + var defineProperty$2 = objectDefineProperty; + + var defineBuiltInAccessor$2 = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn$1(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn$1(descriptor.set, name, { setter: true }); + return defineProperty$2.f(target, name, descriptor); + }; + + var DESCRIPTORS$3 = descriptors; + var FUNCTION_NAME_EXISTS = functionName.EXISTS; + var uncurryThis$a = functionUncurryThis; + var defineBuiltInAccessor$1 = defineBuiltInAccessor$2; + + var FunctionPrototype$1 = Function.prototype; + var functionToString = uncurryThis$a(FunctionPrototype$1.toString); + var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; + var regExpExec = uncurryThis$a(nameRE.exec); + var NAME = 'name'; + + // Function instances `.name` property + // https://tc39.es/ecma262/#sec-function-instances-name + if (DESCRIPTORS$3 && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor$1(FunctionPrototype$1, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); + } + + var objectGetOwnPropertyDescriptor = {}; + + var objectPropertyIsEnumerable = {}; + + var $propertyIsEnumerable = {}.propertyIsEnumerable; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor; + + // Nashorn ~ JDK8 bug + var NASHORN_BUG = getOwnPropertyDescriptor$2 && !$propertyIsEnumerable.call({ 1: 2 }, 1); + + // `Object.prototype.propertyIsEnumerable` method implementation + // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable + objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor$2(this, V); + return !!descriptor && descriptor.enumerable; + } : $propertyIsEnumerable; + + var uncurryThis$9 = functionUncurryThis; + + var toString$1 = uncurryThis$9({}.toString); + var stringSlice = uncurryThis$9(''.slice); + + var classofRaw$2 = function (it) { + return stringSlice(toString$1(it), 8, -1); + }; + + var uncurryThis$8 = functionUncurryThis; + var fails$4 = fails$b; + var classof$5 = classofRaw$2; + + var $Object$1 = Object; + var split = uncurryThis$8(''.split); + + // fallback for non-array-like ES3 and non-enumerable old V8 strings + var indexedObject = fails$4(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object$1('z').propertyIsEnumerable(0); + }) ? function (it) { + return classof$5(it) === 'String' ? split(it, '') : $Object$1(it); + } : $Object$1; + + // toObject with fallback for non-array-like ES3 strings + var IndexedObject$1 = indexedObject; + var requireObjectCoercible = requireObjectCoercible$2; + + var toIndexedObject$3 = function (it) { + return IndexedObject$1(requireObjectCoercible(it)); + }; + + var DESCRIPTORS$2 = descriptors; + var call$9 = functionCall; + var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; + var createPropertyDescriptor = createPropertyDescriptor$2; + var toIndexedObject$2 = toIndexedObject$3; + var toPropertyKey = toPropertyKey$2; + var hasOwn$4 = hasOwnProperty_1; + var IE8_DOM_DEFINE = ie8DomDefine; + + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + + // `Object.getOwnPropertyDescriptor` method + // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor + objectGetOwnPropertyDescriptor.f = DESCRIPTORS$2 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$2(O); + P = toPropertyKey(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn$4(O, P)) return createPropertyDescriptor(!call$9(propertyIsEnumerableModule$1.f, O, P), O[P]); + }; + + var isCallable$8 = isCallable$h; + var definePropertyModule$1 = objectDefineProperty; + var makeBuiltIn = makeBuiltInExports; + var defineGlobalProperty$1 = defineGlobalProperty$3; + + var defineBuiltIn$4 = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable$8(value)) makeBuiltIn(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty$1(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule$1.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; + }; + + var objectGetOwnPropertyNames = {}; + + var ceil = Math.ceil; + var floor = Math.floor; + + // `Math.trunc` method + // https://tc39.es/ecma262/#sec-math.trunc + // eslint-disable-next-line es/no-math-trunc -- safe + var mathTrunc = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor : ceil)(n); + }; + + var trunc = mathTrunc; + + // `ToIntegerOrInfinity` abstract operation + // https://tc39.es/ecma262/#sec-tointegerorinfinity + var toIntegerOrInfinity$2 = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); + }; + + var toIntegerOrInfinity$1 = toIntegerOrInfinity$2; + + var max = Math.max; + var min$1 = Math.min; + + // Helper for a popular repeating case of the spec: + // Let integer be ? ToInteger(index). + // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). + var toAbsoluteIndex$1 = function (index, length) { + var integer = toIntegerOrInfinity$1(index); + return integer < 0 ? max(integer + length, 0) : min$1(integer, length); + }; + + var toIntegerOrInfinity = toIntegerOrInfinity$2; + + var min = Math.min; + + // `ToLength` abstract operation + // https://tc39.es/ecma262/#sec-tolength + var toLength$1 = function (argument) { + return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 + }; + + var toLength = toLength$1; + + // `LengthOfArrayLike` abstract operation + // https://tc39.es/ecma262/#sec-lengthofarraylike + var lengthOfArrayLike$2 = function (obj) { + return toLength(obj.length); + }; + + var toIndexedObject$1 = toIndexedObject$3; + var toAbsoluteIndex = toAbsoluteIndex$1; + var lengthOfArrayLike$1 = lengthOfArrayLike$2; + + // `Array.prototype.{ indexOf, includes }` methods implementation + var createMethod = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject$1($this); + var length = lengthOfArrayLike$1(O); + var index = toAbsoluteIndex(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; + }; + + var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod(false) + }; + + var uncurryThis$7 = functionUncurryThis; + var hasOwn$3 = hasOwnProperty_1; + var toIndexedObject = toIndexedObject$3; + var indexOf = arrayIncludes.indexOf; + var hiddenKeys$1 = hiddenKeys$3; + + var push = uncurryThis$7([].push); + + var objectKeysInternal = function (object, names) { + var O = toIndexedObject(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn$3(hiddenKeys$1, key) && hasOwn$3(O, key) && push(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn$3(O, key = names[i++])) { + ~indexOf(result, key) || push(result, key); + } + return result; + }; + + // IE8- don't enum bug keys + var enumBugKeys$2 = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' + ]; + + var internalObjectKeys$1 = objectKeysInternal; + var enumBugKeys$1 = enumBugKeys$2; + + var hiddenKeys = enumBugKeys$1.concat('length', 'prototype'); + + // `Object.getOwnPropertyNames` method + // https://tc39.es/ecma262/#sec-object.getownpropertynames + // eslint-disable-next-line es/no-object-getownpropertynames -- safe + objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys); + }; + + var objectGetOwnPropertySymbols = {}; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe + objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; + + var getBuiltIn$5 = getBuiltIn$7; + var uncurryThis$6 = functionUncurryThis; + var getOwnPropertyNamesModule = objectGetOwnPropertyNames; + var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; + var anObject$6 = anObject$8; + + var concat$1 = uncurryThis$6([].concat); + + // all object keys, includes non-enumerable and symbols + var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule.f(anObject$6(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f; + return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys; + }; + + var hasOwn$2 = hasOwnProperty_1; + var ownKeys = ownKeys$1; + var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; + var definePropertyModule = objectDefineProperty; + + var copyConstructorProperties$1 = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn$2(target, key) && !(exceptions && hasOwn$2(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } + }; + + var fails$3 = fails$b; + var isCallable$7 = isCallable$h; + + var replacement = /#|\.prototype\./; + + var isForced$2 = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable$7(detection) ? fails$3(detection) + : !!detection; + }; + + var normalize = isForced$2.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); + }; + + var data = isForced$2.data = {}; + var NATIVE = isForced$2.NATIVE = 'N'; + var POLYFILL = isForced$2.POLYFILL = 'P'; + + var isForced_1 = isForced$2; + + var global$7 = global$h; + var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; + var createNonEnumerableProperty = createNonEnumerableProperty$2; + var defineBuiltIn$3 = defineBuiltIn$4; + var defineGlobalProperty = defineGlobalProperty$3; + var copyConstructorProperties = copyConstructorProperties$1; + var isForced$1 = isForced_1; + + /* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key + */ + var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global$7; + } else if (STATIC) { + target = global$7[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = (global$7[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor$1(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced$1(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty(sourceProperty, 'sham', true); + } + defineBuiltIn$3(target, key, sourceProperty, options); + } + }; + + var internalObjectKeys = objectKeysInternal; + var enumBugKeys = enumBugKeys$2; + + // `Object.keys` method + // https://tc39.es/ecma262/#sec-object.keys + // eslint-disable-next-line es/no-object-keys -- safe + var objectKeys$1 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys); + }; + + var DESCRIPTORS$1 = descriptors; + var uncurryThis$5 = functionUncurryThis; + var call$8 = functionCall; + var fails$2 = fails$b; + var objectKeys = objectKeys$1; + var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; + var propertyIsEnumerableModule = objectPropertyIsEnumerable; + var toObject = toObject$2; + var IndexedObject = indexedObject; + + // eslint-disable-next-line es/no-object-assign -- safe + var $assign = Object.assign; + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + var defineProperty$1 = Object.defineProperty; + var concat = uncurryThis$5([].concat); + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + var objectAssign = !$assign || fails$2(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$1 && $assign({ b: 1 }, $assign(defineProperty$1({}, 'a', { + enumerable: true, + get: function () { + defineProperty$1(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet; + }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$1 || call$8(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; + } : $assign; + + var $$6 = _export; + var assign = objectAssign; + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + // eslint-disable-next-line es/no-object-assign -- required for testing + $$6({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign + }); + + var wellKnownSymbol$8 = wellKnownSymbol$a; + + var TO_STRING_TAG$2 = wellKnownSymbol$8('toStringTag'); + var test = {}; + + test[TO_STRING_TAG$2] = 'z'; + + var toStringTagSupport = String(test) === '[object z]'; + + var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; + var isCallable$6 = isCallable$h; + var classofRaw$1 = classofRaw$2; + var wellKnownSymbol$7 = wellKnownSymbol$a; + + var TO_STRING_TAG$1 = wellKnownSymbol$7('toStringTag'); + var $Object = Object; + + // ES3 wrong here + var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments'; + + // fallback for IE11 Script Access Denied error + var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } + }; + + // getting tag from ES6+ `Object.prototype.toString` + var classof$4 = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw$1(O) + // ES3 arguments fallback + : (result = classofRaw$1(O)) === 'Object' && isCallable$6(O.callee) ? 'Arguments' : result; + }; + + var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; + var classof$3 = classof$4; + + // `Object.prototype.toString` method implementation + // https://tc39.es/ecma262/#sec-object.prototype.tostring + var objectToString$1 = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$3(this) + ']'; + }; + + var TO_STRING_TAG_SUPPORT = toStringTagSupport; + var defineBuiltIn$2 = defineBuiltIn$4; + var toString = objectToString$1; + + // `Object.prototype.toString` method + // https://tc39.es/ecma262/#sec-object.prototype.tostring + if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn$2(Object.prototype, 'toString', toString, { unsafe: true }); + } + + var global$6 = global$h; + var classof$2 = classofRaw$2; + + var engineIsNode = classof$2(global$6.process) === 'process'; + + var uncurryThis$4 = functionUncurryThis; + var aCallable$6 = aCallable$8; + + var functionUncurryThisAccessor = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis$4(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } + }; + + var isCallable$5 = isCallable$h; + + var $String = String; + var $TypeError$6 = TypeError; + + var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$5(argument)) return argument; + throw new $TypeError$6("Can't set " + $String(argument) + ' as a prototype'); + }; + + /* eslint-disable no-proto -- safe */ + var uncurryThisAccessor = functionUncurryThisAccessor; + var anObject$5 = anObject$8; + var aPossiblePrototype = aPossiblePrototype$1; + + // `Object.setPrototypeOf` method + // https://tc39.es/ecma262/#sec-object.setprototypeof + // Works with __proto__ only. Old v8 can't work with null proto objects. + // eslint-disable-next-line es/no-object-setprototypeof -- safe + var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject$5(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; + }() : undefined); + + var defineProperty = objectDefineProperty.f; + var hasOwn$1 = hasOwnProperty_1; + var wellKnownSymbol$6 = wellKnownSymbol$a; + + var TO_STRING_TAG = wellKnownSymbol$6('toStringTag'); + + var setToStringTag$1 = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$1(target, TO_STRING_TAG)) { + defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } + }; + + var getBuiltIn$4 = getBuiltIn$7; + var defineBuiltInAccessor = defineBuiltInAccessor$2; + var wellKnownSymbol$5 = wellKnownSymbol$a; + var DESCRIPTORS = descriptors; + + var SPECIES$2 = wellKnownSymbol$5('species'); + + var setSpecies$1 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME); + + if (DESCRIPTORS && Constructor && !Constructor[SPECIES$2]) { + defineBuiltInAccessor(Constructor, SPECIES$2, { + configurable: true, + get: function () { return this; } + }); + } + }; + + var isPrototypeOf$1 = objectIsPrototypeOf; + + var $TypeError$5 = TypeError; + + var anInstance$1 = function (it, Prototype) { + if (isPrototypeOf$1(Prototype, it)) return it; + throw new $TypeError$5('Incorrect invocation'); + }; + + var uncurryThis$3 = functionUncurryThis; + var fails$1 = fails$b; + var isCallable$4 = isCallable$h; + var classof$1 = classof$4; + var getBuiltIn$3 = getBuiltIn$7; + var inspectSource$1 = inspectSource$3; + + var noop = function () { /* empty */ }; + var empty = []; + var construct = getBuiltIn$3('Reflect', 'construct'); + var constructorRegExp = /^\s*(?:class|function)\b/; + var exec = uncurryThis$3(constructorRegExp.exec); + var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + + var isConstructorModern = function isConstructor(argument) { + if (!isCallable$4(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } + }; + + var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$4(argument)) return false; + switch (classof$1(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } + }; + + isConstructorLegacy.sham = true; + + // `IsConstructor` abstract operation + // https://tc39.es/ecma262/#sec-isconstructor + var isConstructor$1 = !construct || fails$1(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; + }) ? isConstructorLegacy : isConstructorModern; + + var isConstructor = isConstructor$1; + var tryToString$2 = tryToString$4; + + var $TypeError$4 = TypeError; + + // `Assert: IsConstructor(argument) is true` + var aConstructor$1 = function (argument) { + if (isConstructor(argument)) return argument; + throw new $TypeError$4(tryToString$2(argument) + ' is not a constructor'); + }; + + var anObject$4 = anObject$8; + var aConstructor = aConstructor$1; + var isNullOrUndefined$1 = isNullOrUndefined$4; + var wellKnownSymbol$4 = wellKnownSymbol$a; + + var SPECIES$1 = wellKnownSymbol$4('species'); + + // `SpeciesConstructor` abstract operation + // https://tc39.es/ecma262/#sec-speciesconstructor + var speciesConstructor$1 = function (O, defaultConstructor) { + var C = anObject$4(O).constructor; + var S; + return C === undefined || isNullOrUndefined$1(S = anObject$4(C)[SPECIES$1]) ? defaultConstructor : aConstructor(S); + }; + + var NATIVE_BIND$1 = functionBindNative; + + var FunctionPrototype = Function.prototype; + var apply$1 = FunctionPrototype.apply; + var call$7 = FunctionPrototype.call; + + // eslint-disable-next-line es/no-reflect -- safe + var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$7.bind(apply$1) : function () { + return call$7.apply(apply$1, arguments); + }); + + var classofRaw = classofRaw$2; + var uncurryThis$2 = functionUncurryThis; + + var functionUncurryThisClause = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis$2(fn); + }; + + var uncurryThis$1 = functionUncurryThisClause; + var aCallable$5 = aCallable$8; + var NATIVE_BIND = functionBindNative; + + var bind$4 = uncurryThis$1(uncurryThis$1.bind); + + // optional / simple context binding + var functionBindContext = function (fn, that) { + aCallable$5(fn); + return that === undefined ? fn : NATIVE_BIND ? bind$4(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; + }; + + var getBuiltIn$2 = getBuiltIn$7; + + var html$1 = getBuiltIn$2('document', 'documentElement'); + + var uncurryThis = functionUncurryThis; + + var arraySlice$1 = uncurryThis([].slice); + + var $TypeError$3 = TypeError; + + var validateArgumentsLength$1 = function (passed, required) { + if (passed < required) throw new $TypeError$3('Not enough arguments'); + return passed; + }; + + var userAgent$2 = engineUserAgent; + + // eslint-disable-next-line redos/no-vulnerable -- safe + var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2); + + var global$5 = global$h; + var apply = functionApply; + var bind$3 = functionBindContext; + var isCallable$3 = isCallable$h; + var hasOwn = hasOwnProperty_1; + var fails = fails$b; + var html = html$1; + var arraySlice = arraySlice$1; + var createElement = documentCreateElement; + var validateArgumentsLength = validateArgumentsLength$1; + var IS_IOS$1 = engineIsIos; + var IS_NODE$3 = engineIsNode; + + var set = global$5.setImmediate; + var clear = global$5.clearImmediate; + var process$2 = global$5.process; + var Dispatch = global$5.Dispatch; + var Function$1 = global$5.Function; + var MessageChannel = global$5.MessageChannel; + var String$1 = global$5.String; + var counter = 0; + var queue$2 = {}; + var ONREADYSTATECHANGE = 'onreadystatechange'; + var $location, defer, channel, port; + + fails(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = global$5.location; + }); + + var run = function (id) { + if (hasOwn(queue$2, id)) { + var fn = queue$2[id]; + delete queue$2[id]; + fn(); + } + }; + + var runner = function (id) { + return function () { + run(id); + }; + }; + + var eventListener = function (event) { + run(event.data); + }; + + var globalPostMessageDefer = function (id) { + // old engines have not location.origin + global$5.postMessage(String$1(id), $location.protocol + '//' + $location.host); + }; + + // Node.js 0.9+ & IE10+ has setImmediate, otherwise: + if (!set || !clear) { + set = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable$3(handler) ? handler : Function$1(handler); + var args = arraySlice(arguments, 1); + queue$2[++counter] = function () { + apply(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue$2[id]; + }; + // Node.js 0.8- + if (IS_NODE$3) { + defer = function (id) { + process$2.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS$1) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind$3(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global$5.addEventListener && + isCallable$3(global$5.postMessage) && + !global$5.importScripts && + $location && $location.protocol !== 'file:' && + !fails(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + global$5.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } + } + + var task$1 = { + set: set, + clear: clear + }; + + var Queue$2 = function () { + this.head = null; + this.tail = null; + }; + + Queue$2.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } + }; + + var queue$1 = Queue$2; + + var userAgent$1 = engineUserAgent; + + var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && typeof Pebble != 'undefined'; + + var userAgent = engineUserAgent; + + var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent); + + var global$4 = global$h; + var bind$2 = functionBindContext; + var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + var macrotask = task$1.set; + var Queue$1 = queue$1; + var IS_IOS = engineIsIos; + var IS_IOS_PEBBLE = engineIsIosPebble; + var IS_WEBOS_WEBKIT = engineIsWebosWebkit; + var IS_NODE$2 = engineIsNode; + + var MutationObserver = global$4.MutationObserver || global$4.WebKitMutationObserver; + var document$2 = global$4.document; + var process$1 = global$4.process; + var Promise$1 = global$4.Promise; + // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` + var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$4, 'queueMicrotask'); + var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; + var notify$1, toggle, node, promise, then; + + // modern engines have queueMicrotask method + if (!microtask$1) { + var queue = new Queue$1(); + + var flush = function () { + var parent, fn; + if (IS_NODE$2 && (parent = process$1.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify$1(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { + toggle = true; + node = document$2.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify$1 = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise$1.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise$1; + then = bind$2(promise.then, promise); + notify$1 = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE$2) { + notify$1 = function () { + process$1.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind$2(macrotask, global$4); + notify$1 = function () { + macrotask(flush); + }; + } + + microtask$1 = function (fn) { + if (!queue.head) notify$1(); + queue.add(fn); + }; + } + + var microtask_1 = microtask$1; + + var hostReportErrors$1 = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } + }; + + var perform$3 = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } + }; + + var global$3 = global$h; + + var promiseNativeConstructor = global$3.Promise; + + /* global Deno -- Deno case */ + var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object'; + + var IS_DENO$1 = engineIsDeno; + var IS_NODE$1 = engineIsNode; + + var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 + && typeof window == 'object' + && typeof document == 'object'; + + var global$2 = global$h; + var NativePromiseConstructor$3 = promiseNativeConstructor; + var isCallable$2 = isCallable$h; + var isForced = isForced_1; + var inspectSource = inspectSource$3; + var wellKnownSymbol$3 = wellKnownSymbol$a; + var IS_BROWSER = engineIsBrowser; + var IS_DENO = engineIsDeno; + var V8_VERSION = engineV8Version; + + NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype; + var SPECIES = wellKnownSymbol$3('species'); + var SUBCLASSING = false; + var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$2(global$2.PromiseRejectionEvent); + + var FORCED_PROMISE_CONSTRUCTOR$5 = isForced('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1; + }); + + var promiseConstructorDetection = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1, + SUBCLASSING: SUBCLASSING + }; + + var newPromiseCapability$2 = {}; + + var aCallable$4 = aCallable$8; + + var $TypeError$2 = TypeError; + + var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError$2('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable$4(resolve); + this.reject = aCallable$4(reject); + }; + + // `NewPromiseCapability` abstract operation + // https://tc39.es/ecma262/#sec-newpromisecapability + newPromiseCapability$2.f = function (C) { + return new PromiseCapability(C); + }; + + var $$5 = _export; + var IS_NODE = engineIsNode; + var global$1 = global$h; + var call$6 = functionCall; + var defineBuiltIn$1 = defineBuiltIn$4; + var setPrototypeOf = objectSetPrototypeOf; + var setToStringTag = setToStringTag$1; + var setSpecies = setSpecies$1; + var aCallable$3 = aCallable$8; + var isCallable$1 = isCallable$h; + var isObject$2 = isObject$8; + var anInstance = anInstance$1; + var speciesConstructor = speciesConstructor$1; + var task = task$1.set; + var microtask = microtask_1; + var hostReportErrors = hostReportErrors$1; + var perform$2 = perform$3; + var Queue = queue$1; + var InternalStateModule = internalState; + var NativePromiseConstructor$2 = promiseNativeConstructor; + var PromiseConstructorDetection = promiseConstructorDetection; + var newPromiseCapabilityModule$3 = newPromiseCapability$2; + + var PROMISE = 'Promise'; + var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR; + var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; + var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; + var getInternalPromiseState = InternalStateModule.getterFor(PROMISE); + var setInternalState = InternalStateModule.set; + var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype; + var PromiseConstructor = NativePromiseConstructor$2; + var PromisePrototype = NativePromisePrototype$1; + var TypeError$1 = global$1.TypeError; + var document$1 = global$1.document; + var process = global$1.process; + var newPromiseCapability$1 = newPromiseCapabilityModule$3.f; + var newGenericPromiseCapability = newPromiseCapability$1; + + var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$1.dispatchEvent); + var UNHANDLED_REJECTION = 'unhandledrejection'; + var REJECTION_HANDLED = 'rejectionhandled'; + var PENDING = 0; + var FULFILLED = 1; + var REJECTED = 2; + var HANDLED = 1; + var UNHANDLED = 2; + + var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + + // helpers + var isThenable = function (it) { + var then; + return isObject$2(it) && isCallable$1(then = it.then) ? then : false; + }; + + var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$6(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } + }; + + var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); + }; + + var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$1.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global$1.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$1['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); + }; + + var onUnhandled = function (state) { + call$6(task, global$1, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform$2(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); + }; + + var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; + }; + + var onHandleUnhandled = function (state) { + call$6(task, global$1, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); + }; + + var bind$1 = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; + }; + + var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); + }; + + var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call$6(then, value, + bind$1(internalResolve, wrapper, state), + bind$1(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } + }; + + // constructor polyfill + if (FORCED_PROMISE_CONSTRUCTOR$4) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance(this, PromisePrototype); + aCallable$3(executor); + call$6(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind$1(internalResolve, state), bind$1(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: undefined + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn$1(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable$1(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$1(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind$1(internalResolve, state); + this.reject = bind$1(internalReject, state); + }; + + newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (isCallable$1(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) { + nativeThen = NativePromisePrototype$1.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn$1(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call$6(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype$1.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf) { + setPrototypeOf(NativePromisePrototype$1, PromisePrototype); + } + } + } + + $$5({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, { + Promise: PromiseConstructor + }); + + setToStringTag(PromiseConstructor, PROMISE, false); + setSpecies(PROMISE); + + var iterators = {}; + + var wellKnownSymbol$2 = wellKnownSymbol$a; + var Iterators$1 = iterators; + + var ITERATOR$2 = wellKnownSymbol$2('iterator'); + var ArrayPrototype = Array.prototype; + + // check on default Array iterator + var isArrayIteratorMethod$1 = function (it) { + return it !== undefined && (Iterators$1.Array === it || ArrayPrototype[ITERATOR$2] === it); + }; + + var classof = classof$4; + var getMethod$1 = getMethod$3; + var isNullOrUndefined = isNullOrUndefined$4; + var Iterators = iterators; + var wellKnownSymbol$1 = wellKnownSymbol$a; + + var ITERATOR$1 = wellKnownSymbol$1('iterator'); + + var getIteratorMethod$2 = function (it) { + if (!isNullOrUndefined(it)) return getMethod$1(it, ITERATOR$1) + || getMethod$1(it, '@@iterator') + || Iterators[classof(it)]; + }; + + var call$5 = functionCall; + var aCallable$2 = aCallable$8; + var anObject$3 = anObject$8; + var tryToString$1 = tryToString$4; + var getIteratorMethod$1 = getIteratorMethod$2; + + var $TypeError$1 = TypeError; + + var getIterator$1 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator; + if (aCallable$2(iteratorMethod)) return anObject$3(call$5(iteratorMethod, argument)); + throw new $TypeError$1(tryToString$1(argument) + ' is not iterable'); + }; + + var call$4 = functionCall; + var anObject$2 = anObject$8; + var getMethod = getMethod$3; + + var iteratorClose$1 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$2(iterator); + try { + innerResult = getMethod(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$4(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$2(innerResult); + return value; + }; + + var bind = functionBindContext; + var call$3 = functionCall; + var anObject$1 = anObject$8; + var tryToString = tryToString$4; + var isArrayIteratorMethod = isArrayIteratorMethod$1; + var lengthOfArrayLike = lengthOfArrayLike$2; + var isPrototypeOf = objectIsPrototypeOf; + var getIterator = getIterator$1; + var getIteratorMethod = getIteratorMethod$2; + var iteratorClose = iteratorClose$1; + + var $TypeError = TypeError; + + var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; + }; + + var ResultPrototype = Result.prototype; + + var iterate$2 = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject$1(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call$3(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + }; + + var wellKnownSymbol = wellKnownSymbol$a; + + var ITERATOR = wellKnownSymbol('iterator'); + var SAFE_CLOSING = false; + + try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); + } catch (error) { /* empty */ } + + var checkCorrectnessOfIteration$1 = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; + }; + + var NativePromiseConstructor$1 = promiseNativeConstructor; + var checkCorrectnessOfIteration = checkCorrectnessOfIteration$1; + var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR; + + var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration(function (iterable) { + NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ }); + }); + + var $$4 = _export; + var call$2 = functionCall; + var aCallable$1 = aCallable$8; + var newPromiseCapabilityModule$2 = newPromiseCapability$2; + var perform$1 = perform$3; + var iterate$1 = iterate$2; + var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration; + + // `Promise.all` method + // https://tc39.es/ecma262/#sec-promise.all + $$4({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$2.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform$1(function () { + var $promiseResolve = aCallable$1(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$1(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$2($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var $$3 = _export; + var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR; + var NativePromiseConstructor = promiseNativeConstructor; + var getBuiltIn$1 = getBuiltIn$7; + var isCallable = isCallable$h; + var defineBuiltIn = defineBuiltIn$4; + + var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + + // `Promise.prototype.catch` method + // https://tc39.es/ecma262/#sec-promise.prototype.catch + $$3({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + + // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` + if (isCallable(NativePromiseConstructor)) { + var method = getBuiltIn$1('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true }); + } + } + + var $$2 = _export; + var call$1 = functionCall; + var aCallable = aCallable$8; + var newPromiseCapabilityModule$1 = newPromiseCapability$2; + var perform = perform$3; + var iterate = iterate$2; + var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration; + + // `Promise.race` method + // https://tc39.es/ecma262/#sec-promise.race + $$2({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$1.f(C); + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aCallable(C.resolve); + iterate(iterable, function (promise) { + call$1($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var $$1 = _export; + var call = functionCall; + var newPromiseCapabilityModule = newPromiseCapability$2; + var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR; + + // `Promise.reject` method + // https://tc39.es/ecma262/#sec-promise.reject + $$1({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule.f(this); + call(capability.reject, undefined, r); + return capability.promise; + } + }); + + var anObject = anObject$8; + var isObject$1 = isObject$8; + var newPromiseCapability = newPromiseCapability$2; + + var promiseResolve$1 = function (C, x) { + anObject(C); + if (isObject$1(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; + }; + + var $ = _export; + var getBuiltIn = getBuiltIn$7; + var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR; + var promiseResolve = promiseResolve$1; + + getBuiltIn('Promise'); + + // `Promise.resolve` method + // https://tc39.es/ecma262/#sec-promise.resolve + $({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(this, x); + } + }); + + function defined(x) { + return x != null && !Number.isNaN(x); + } + + function ascendingDefined(a, b) { + return +defined(b) - +defined(a) || d3.ascending(a, b); + } + + function finite(x) { + return isFinite(x) ? x : NaN; + } + + function positive(x) { + return x > 0 && isFinite(x) ? x : NaN; + } + + function negative(x) { + return x < 0 && isFinite(x) ? x : NaN; + } + + function format(date, fallback) { + if (!(date instanceof Date)) date = new Date(+date); + if (isNaN(date)) return typeof fallback === "function" ? fallback(date) : fallback; + const hours = date.getUTCHours(); + const minutes = date.getUTCMinutes(); + const seconds = date.getUTCSeconds(); + const milliseconds = date.getUTCMilliseconds(); + return `${formatYear(date.getUTCFullYear())}-${pad(date.getUTCMonth() + 1, 2)}-${pad(date.getUTCDate(), 2)}${ + hours || minutes || seconds || milliseconds ? `T${pad(hours, 2)}:${pad(minutes, 2)}${ + seconds || milliseconds ? `:${pad(seconds, 2)}${ + milliseconds ? `.${pad(milliseconds, 3)}` : `` + }` : `` + }Z` : `` + }`; + } + + function formatYear(year) { + return year < 0 ? `-${pad(-year, 6)}` + : year > 9999 ? `+${pad(year, 6)}` + : pad(year, 4); + } + + function pad(value, width) { + return `${value}`.padStart(width, "0"); + } + + const re = /^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/; + + function parse(string, fallback) { + if (!re.test(string += "")) return typeof fallback === "function" ? fallback(string) : fallback; + return new Date(string); + } + + const timeIntervals = new Map([ + ["second", d3.timeSecond], + ["minute", d3.timeMinute], + ["hour", d3.timeHour], + ["day", d3.timeDay], + ["week", d3.timeWeek], + ["month", d3.timeMonth], + ["quarter", d3.timeMonth.every(3)], + ["half", d3.timeMonth.every(6)], + ["year", d3.timeYear], + ["monday", d3.timeMonday], + ["tuesday", d3.timeTuesday], + ["wednesday", d3.timeWednesday], + ["thursday", d3.timeThursday], + ["friday", d3.timeFriday], + ["saturday", d3.timeSaturday], + ["sunday", d3.timeSunday] + ]); + + const utcIntervals = new Map([ + ["second", d3.utcSecond], + ["minute", d3.utcMinute], + ["hour", d3.utcHour], + ["day", d3.utcDay], + ["week", d3.utcWeek], + ["month", d3.utcMonth], + ["quarter", d3.utcMonth.every(3)], + ["half", d3.utcMonth.every(6)], + ["year", d3.utcYear], + ["monday", d3.utcMonday], + ["tuesday", d3.utcTuesday], + ["wednesday", d3.utcWednesday], + ["thursday", d3.utcThursday], + ["friday", d3.utcFriday], + ["saturday", d3.utcSaturday], + ["sunday", d3.utcSunday] + ]); + + function maybeTimeInterval(interval) { + const i = timeIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; + } + + function maybeUtcInterval(interval) { + const i = utcIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; + } + + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + const TypedArray = Object.getPrototypeOf(Uint8Array); + const objectToString = Object.prototype.toString; + const string = (x) => (x == null ? x : `${x}`); + const constant = (x) => () => x; + + // If the values are specified as a typed array, no coercion is required. + function coerceNumbers(values) { + return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array); + } + + // Unlike Mark’s number, here we want to convert null and undefined to NaN since + // the result will be stored in a Float64Array and we don’t want null to be + // coerced to zero. We use Number instead of unary + to allow BigInt coercion. + function coerceNumber(x) { + return x == null ? NaN : Number(x); + } + + function coerceDates(values) { + return map(values, coerceDate); + } + + // When coercing strings to dates, we only want to allow the ISO 8601 format + // since the built-in string parsing of the Date constructor varies across + // browsers. (In the future, this could be made more liberal if desired, though + // it is still generally preferable to do date parsing yourself explicitly, + // rather than rely on Plot.) Any non-string values are coerced to number first + // and treated as milliseconds since UNIX epoch. + function coerceDate(x) { + return x instanceof Date && !isNaN(x) + ? x + : typeof x === "string" + ? parse(x) + : x == null || isNaN((x = +x)) + ? undefined + : new Date(x); + } + + // Some channels may allow a string constant to be specified; to differentiate + // string constants (e.g., "red") from named fields (e.g., "date"), this + // function tests whether the given value is a CSS color string and returns a + // tuple [channel, constant] where one of the two is undefined, and the other is + // the given value. If you wish to reference a named field that is also a valid + // CSS color, use an accessor (d => d.red) instead. + function maybeColorChannel(value, defaultValue) { + if (value === undefined) value = defaultValue; + return value === null ? [undefined, "none"] : isColor(value) ? [undefined, value] : [value, undefined]; + } + + // Similar to maybeColorChannel, this tests whether the given value is a number + // indicating a constant, and otherwise assumes that it’s a channel value. + function maybeNumberChannel(value, defaultValue) { + if (value === undefined) value = defaultValue; + return value === null || typeof value === "number" ? [undefined, value] : [value, undefined]; + } + + // Promotes the specified data to an array as needed. + function arrayify(data) { + return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data); + } + + // An optimization of type.from(values, f): if the given values are already an + // instanceof the desired array type, the faster values.map method is used. + function map(values, f, type = Array) { + return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f); + } + + // An optimization of type.from(values): if the given values are already an + // instanceof the desired array type, the faster values.slice method is used. + function slice(values, type = Array) { + return values instanceof type ? values.slice() : type.from(values); + } + + // Disambiguates an options object (e.g., {y: "x2"}) from a primitive value. + function isObject(option) { + return option?.toString === objectToString; + } + + // Disambiguates a scale options object (e.g., {color: {type: "linear"}}) from + // some other option (e.g., {color: "red"}). When creating standalone legends, + // this is used to test whether a scale is defined; this should be consistent + // with inferScaleType when there are no channels associated with the scale, and + // if this returns true, then normalizeScale must return non-null. + function isScaleOptions(option) { + return isObject(option) && (option.type !== undefined || option.domain !== undefined); + } + + // If interval is not nullish, converts interval shorthand such as a number (for + // multiples) or a time interval name (such as “day”) to a {floor, offset, + // range} object similar to a D3 time interval. + function maybeInterval(interval, type) { + if (interval == null) return; + if (typeof interval === "number") { + if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval; + const n = Math.abs(interval); + return interval < 0 + ? { + floor: (d) => Math.floor(d * n) / n, + offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity + range: (lo, hi) => d3.range(Math.ceil(lo * n), hi * n).map((x) => x / n) + } + : { + floor: (d) => Math.floor(d / n) * n, + offset: (d) => d + n, // note: no optional step for simplicity + range: (lo, hi) => d3.range(Math.ceil(lo / n), hi / n).map((x) => x * n) + }; + } + if (typeof interval === "string") return (type === "time" ? maybeTimeInterval : maybeUtcInterval)(interval); + if (typeof interval.floor !== "function") throw new Error("invalid interval; missing floor method"); + if (typeof interval.offset !== "function") throw new Error("invalid interval; missing offset method"); + return interval; + } + + // Like maybeInterval, but requires a range method too. + function maybeRangeInterval(interval, type) { + interval = maybeInterval(interval, type); + if (interval && typeof interval.range !== "function") throw new Error("invalid interval: missing range method"); + return interval; + } + + // Like maybeRangeInterval, but requires a ceil method too. + function maybeNiceInterval(interval, type) { + interval = maybeRangeInterval(interval, type); + if (interval && typeof interval.ceil !== "function") throw new Error("invalid interval: missing ceil method"); + return interval; + } + + function isOrdinal(values) { + for (const value of values) { + if (value == null) continue; + const type = typeof value; + return type === "string" || type === "boolean"; + } + } + + function isTemporal(values) { + for (const value of values) { + if (value == null) continue; + return value instanceof Date; + } + } + + // Are these strings that might represent dates? This is stricter than ISO 8601 + // because we want to ignore false positives on numbers; for example, the string + // "1192" is more likely to represent a number than a date even though it is + // valid ISO 8601 representing 1192-01-01. + function isTemporalString(values) { + for (const value of values) { + if (value == null) continue; + return typeof value === "string" && isNaN(value) && parse(value); + } + } + + // Are these strings that might represent numbers? This is stricter than + // coercion because we want to ignore false positives on e.g. empty strings. + function isNumericString(values) { + for (const value of values) { + if (value == null) continue; + if (typeof value !== "string") return false; + if (!value.trim()) continue; + return !isNaN(value); + } + } + + // Mostly relies on d3-color, with a few extra color keywords. Currently this + // strictly requires that the value be a string; we might want to apply string + // coercion here, though note that d3-color instances would need to support + // valueOf to work correctly with InternMap. + // https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint + function isColor(value) { + if (typeof value !== "string") return false; + value = value.toLowerCase().trim(); + return ( + value === "none" || + value === "currentcolor" || + (value.startsWith("url(") && value.endsWith(")")) || // , e.g. pattern or gradient + (value.startsWith("var(") && value.endsWith(")")) || // CSS variable + d3.color(value) !== null + ); + } + + function isNoneish(value) { + return value == null || isNone(value); + } + + function isNone(value) { + return /^\s*none\s*$/i.test(value); + } + + // Like a sort comparator, returns a positive value if the given array of values + // is in ascending order, a negative value if the values are in descending + // order. Assumes monotonicity; only tests the first and last values. + function orderof(values) { + if (values == null) return; + const first = values[0]; + const last = values[values.length - 1]; + return d3.descending(first, last); + } + + // Unlike {...defaults, ...options}, this ensures that any undefined (but + // present) properties in options inherit the given default value. + function inherit(options = {}, ...rest) { + let o = options; + for (const defaults of rest) { + for (const key in defaults) { + if (o[key] === undefined) { + const value = defaults[key]; + if (o === options) o = {...o, [key]: value}; + else o[key] = value; + } + } + } + return o; + } + + // Positional scales have associated axes, and for ordinal data, a point or band + // scale is used instead of an ordinal scale. + const position = Symbol("position"); + + // Color scales default to the turbo interpolator for quantitative data, and to + // the Tableau10 scheme for ordinal data. Color scales may also have an + // associated legend. + const color = Symbol("color"); + + // Radius scales default to the sqrt type, have a default range of [0, 3], and a + // default domain from 0 to the median first quartile of associated channels. + const radius = Symbol("radius"); + + // Length scales default to the linear type, have a default range of [0, 12], + // and a default domain from 0 to the median median of associated channels. + const length = Symbol("length"); + + // Opacity scales have a default range of [0, 1], and a default domain from 0 to + // the maximum value of associated channels. + const opacity = Symbol("opacity"); + + // Symbol scales have a default range of categorical symbols. + const symbol = Symbol("symbol"); + + // TODO Rather than hard-coding the list of known scale names, collect the names + // and categories for each plot specification, so that custom marks can register + // custom scales. + const registry = new Map([ + ["x", position], + ["y", position], + ["fx", position], + ["fy", position], + ["r", radius], + ["color", color], + ["opacity", opacity], + ["symbol", symbol], + ["length", length] + ]); + + const sqrt3 = Math.sqrt(3); + const sqrt4_3 = 2 / sqrt3; + + const symbolHexagon = { + draw(context, size) { + const rx = Math.sqrt(size / Math.PI), + ry = rx * sqrt4_3, + hy = ry / 2; + context.moveTo(0, ry); + context.lineTo(rx, hy); + context.lineTo(rx, -hy); + context.lineTo(0, -ry); + context.lineTo(-rx, -hy); + context.lineTo(-rx, hy); + context.closePath(); + } + }; + + const symbols = new Map([ + ["asterisk", d3.symbolAsterisk], + ["circle", d3.symbolCircle], + ["cross", d3.symbolCross], + ["diamond", d3.symbolDiamond], + ["diamond2", d3.symbolDiamond2], + ["hexagon", symbolHexagon], + ["plus", d3.symbolPlus], + ["square", d3.symbolSquare], + ["square2", d3.symbolSquare2], + ["star", d3.symbolStar], + ["times", d3.symbolTimes], + ["triangle", d3.symbolTriangle], + ["triangle2", d3.symbolTriangle2], + ["wye", d3.symbolWye] + ]); + + function isSymbolObject(value) { + return value && typeof value.draw === "function"; + } + + function maybeSymbol(symbol) { + if (symbol == null || isSymbolObject(symbol)) return symbol; + const value = symbols.get(`${symbol}`.toLowerCase()); + if (value) return value; + throw new Error(`invalid symbol: ${symbol}`); + } + + function warn(message) { + console.warn(message); + } + + const pi = Math.PI; + const tau = 2 * pi; + + function createProjection( + { + projection, + inset: globalInset = 0, + insetTop = globalInset, + insetRight = globalInset, + insetBottom = globalInset, + insetLeft = globalInset + } = {}, + dimensions + ) { + if (projection == null) return; + if (typeof projection.stream === "function") return projection; // d3 projection + let options; + let domain; + let clip = "frame"; + + // If the projection was specified as an object with additional options, + // extract those. The order of precedence for insetTop (and other insets) is: + // projection.insetTop, projection.inset, (global) insetTop, (global) inset. + // Any other options on this object will be passed through to the initializer. + if (isObject(projection)) { + let inset; + ({ + type: projection, + domain, + inset, + insetTop = inset !== undefined ? inset : insetTop, + insetRight = inset !== undefined ? inset : insetRight, + insetBottom = inset !== undefined ? inset : insetBottom, + insetLeft = inset !== undefined ? inset : insetLeft, + clip = clip, + ...options + } = projection); + if (projection == null) return; + } + + // For named projections, retrieve the corresponding projection initializer. + if (typeof projection !== "function") ({type: projection} = namedProjection(projection)); + + // Compute the frame dimensions and invoke the projection initializer. + const {width, height, marginLeft, marginRight, marginTop, marginBottom} = dimensions; + const dx = width - marginLeft - marginRight - insetLeft - insetRight; + const dy = height - marginTop - marginBottom - insetTop - insetBottom; + projection = projection?.({width: dx, height: dy, clip, ...options}); + + // The projection initializer might decide to not use a projection. + if (projection == null) return; + clip = maybePostClip(clip, marginLeft, marginTop, width - marginRight, height - marginBottom); + + // Translate the origin to the top-left corner, respecting margins and insets. + let tx = marginLeft + insetLeft; + let ty = marginTop + insetTop; + let transform; + + // If a domain is specified, fit the projection to the frame. + if (domain != null) { + const [[x0, y0], [x1, y1]] = d3.geoPath(projection).bounds(domain); + const k = Math.min(dx / (x1 - x0), dy / (y1 - y0)); + if (k > 0) { + tx -= (k * (x0 + x1) - dx) / 2; + ty -= (k * (y0 + y1) - dy) / 2; + transform = d3.geoTransform({ + point(x, y) { + this.stream.point(x * k + tx, y * k + ty); + } + }); + } else { + warn(`Warning: the projection could not be fit to the specified domain; using the default scale.`); + } + } + + transform ??= + tx === 0 && ty === 0 + ? identity() + : d3.geoTransform({ + point(x, y) { + this.stream.point(x + tx, y + ty); + } + }); + + return {stream: (s) => projection.stream(transform.stream(clip(s)))}; + } + + function namedProjection(projection) { + switch (`${projection}`.toLowerCase()) { + case "albers-usa": + return scaleProjection(d3.geoAlbersUsa, 0.7463, 0.4673); + case "albers": + return conicProjection(d3.geoAlbers, 0.7463, 0.4673); + case "azimuthal-equal-area": + return scaleProjection(d3.geoAzimuthalEqualArea, 4, 4); + case "azimuthal-equidistant": + return scaleProjection(d3.geoAzimuthalEquidistant, tau, tau); + case "conic-conformal": + return conicProjection(d3.geoConicConformal, tau, tau); + case "conic-equal-area": + return conicProjection(d3.geoConicEqualArea, 6.1702, 2.9781); + case "conic-equidistant": + return conicProjection(d3.geoConicEquidistant, 7.312, 3.6282); + case "equal-earth": + return scaleProjection(d3.geoEqualEarth, 5.4133, 2.6347); + case "equirectangular": + return scaleProjection(d3.geoEquirectangular, tau, pi); + case "gnomonic": + return scaleProjection(d3.geoGnomonic, 3.4641, 3.4641); + case "identity": + return {type: identity}; + case "reflect-y": + return {type: reflectY}; + case "mercator": + return scaleProjection(d3.geoMercator, tau, tau); + case "orthographic": + return scaleProjection(d3.geoOrthographic, 2, 2); + case "stereographic": + return scaleProjection(d3.geoStereographic, 2, 2); + case "transverse-mercator": + return scaleProjection(d3.geoTransverseMercator, tau, tau); + default: + throw new Error(`unknown projection type: ${projection}`); + } + } + + function maybePostClip(clip, x1, y1, x2, y2) { + if (clip === false || clip == null || typeof clip === "number") return (s) => s; + if (clip === true) clip = "frame"; + switch (`${clip}`.toLowerCase()) { + case "frame": + return d3.geoClipRectangle(x1, y1, x2, y2); + default: + throw new Error(`unknown projection clip type: ${clip}`); + } + } + + function scaleProjection(createProjection, kx, ky) { + return { + type: ({width, height, rotate, precision = 0.15, clip}) => { + const projection = createProjection(); + if (precision != null) projection.precision?.(precision); + if (rotate != null) projection.rotate?.(rotate); + if (typeof clip === "number") projection.clipAngle?.(clip); + projection.scale(Math.min(width / kx, height / ky)); + projection.translate([width / 2, height / 2]); + return projection; + }, + aspectRatio: ky / kx + }; + } + + function conicProjection(createProjection, kx, ky) { + const {type, aspectRatio} = scaleProjection(createProjection, kx, ky); + return { + type: (options) => { + const {parallels, domain, width, height} = options; + const projection = type(options); + if (parallels != null) { + projection.parallels(parallels); + if (domain === undefined) { + projection.fitSize([width, height], {type: "Sphere"}); + } + } + return projection; + }, + aspectRatio + }; + } + + const identity = constant({stream: (stream) => stream}); + + const reflectY = constant( + d3.geoTransform({ + point(x, y) { + this.stream.point(x, -y); + } + }) + ); + + function createContext(options = {}, dimensions, className) { + const {document = typeof window !== "undefined" ? window.document : undefined} = options; + return {document, className, projection: createProjection(options, dimensions)}; + } + + function create(name, {document}) { + return d3.select(d3.creator(name).call(document.documentElement)); + } + + const ordinalSchemes = new Map([ + // categorical + ["accent", d3.schemeAccent], + ["category10", d3.schemeCategory10], + ["dark2", d3.schemeDark2], + ["paired", d3.schemePaired], + ["pastel1", d3.schemePastel1], + ["pastel2", d3.schemePastel2], + ["set1", d3.schemeSet1], + ["set2", d3.schemeSet2], + ["set3", d3.schemeSet3], + ["tableau10", d3.schemeTableau10], + + // diverging + ["brbg", scheme11(d3.schemeBrBG, d3.interpolateBrBG)], + ["prgn", scheme11(d3.schemePRGn, d3.interpolatePRGn)], + ["piyg", scheme11(d3.schemePiYG, d3.interpolatePiYG)], + ["puor", scheme11(d3.schemePuOr, d3.interpolatePuOr)], + ["rdbu", scheme11(d3.schemeRdBu, d3.interpolateRdBu)], + ["rdgy", scheme11(d3.schemeRdGy, d3.interpolateRdGy)], + ["rdylbu", scheme11(d3.schemeRdYlBu, d3.interpolateRdYlBu)], + ["rdylgn", scheme11(d3.schemeRdYlGn, d3.interpolateRdYlGn)], + ["spectral", scheme11(d3.schemeSpectral, d3.interpolateSpectral)], + + // reversed diverging (for temperature data) + ["burd", scheme11r(d3.schemeRdBu, d3.interpolateRdBu)], + ["buylrd", scheme11r(d3.schemeRdYlBu, d3.interpolateRdYlBu)], + + // sequential (single-hue) + ["blues", scheme9(d3.schemeBlues, d3.interpolateBlues)], + ["greens", scheme9(d3.schemeGreens, d3.interpolateGreens)], + ["greys", scheme9(d3.schemeGreys, d3.interpolateGreys)], + ["oranges", scheme9(d3.schemeOranges, d3.interpolateOranges)], + ["purples", scheme9(d3.schemePurples, d3.interpolatePurples)], + ["reds", scheme9(d3.schemeReds, d3.interpolateReds)], + + // sequential (multi-hue) + ["turbo", schemei(d3.interpolateTurbo)], + ["viridis", schemei(d3.interpolateViridis)], + ["magma", schemei(d3.interpolateMagma)], + ["inferno", schemei(d3.interpolateInferno)], + ["plasma", schemei(d3.interpolatePlasma)], + ["cividis", schemei(d3.interpolateCividis)], + ["cubehelix", schemei(d3.interpolateCubehelixDefault)], + ["warm", schemei(d3.interpolateWarm)], + ["cool", schemei(d3.interpolateCool)], + ["bugn", scheme9(d3.schemeBuGn, d3.interpolateBuGn)], + ["bupu", scheme9(d3.schemeBuPu, d3.interpolateBuPu)], + ["gnbu", scheme9(d3.schemeGnBu, d3.interpolateGnBu)], + ["orrd", scheme9(d3.schemeOrRd, d3.interpolateOrRd)], + ["pubu", scheme9(d3.schemePuBu, d3.interpolatePuBu)], + ["pubugn", scheme9(d3.schemePuBuGn, d3.interpolatePuBuGn)], + ["purd", scheme9(d3.schemePuRd, d3.interpolatePuRd)], + ["rdpu", scheme9(d3.schemeRdPu, d3.interpolateRdPu)], + ["ylgn", scheme9(d3.schemeYlGn, d3.interpolateYlGn)], + ["ylgnbu", scheme9(d3.schemeYlGnBu, d3.interpolateYlGnBu)], + ["ylorbr", scheme9(d3.schemeYlOrBr, d3.interpolateYlOrBr)], + ["ylorrd", scheme9(d3.schemeYlOrRd, d3.interpolateYlOrRd)], + + // cyclical + ["rainbow", schemeicyclical(d3.interpolateRainbow)], + ["sinebow", schemeicyclical(d3.interpolateSinebow)] + ]); + + function scheme9(scheme, interpolate) { + return ({length: n}) => { + if (n === 1) return [scheme[3][1]]; // favor midpoint + if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker + n = Math.max(3, Math.floor(n)); + return n > 9 ? d3.quantize(interpolate, n) : scheme[n]; + }; + } + + function scheme11(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? d3.quantize(interpolate, n) : scheme[n]; + }; + } + + function scheme11r(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? d3.quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse(); + }; + } + + function schemei(interpolate) { + return ({length: n}) => d3.quantize(interpolate, Math.max(2, Math.floor(n))); + } + + function schemeicyclical(interpolate) { + return ({length: n}) => d3.quantize(interpolate, Math.floor(n) + 1).slice(0, -1); + } + + function ordinalScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`); + return ordinalSchemes.get(s); + } + + function ordinalRange(scheme, length) { + const s = ordinalScheme(scheme); + const r = typeof s === "function" ? s({length}) : s; + return r.length !== length ? r.slice(0, length) : r; + } + + // If the specified domain contains only booleans (ignoring null and undefined), + // returns a corresponding range where false is mapped to the low color and true + // is mapped to the high color of the specified scheme. + function maybeBooleanRange(domain, scheme = "greys") { + const range = new Set(); + const [f, t] = ordinalRange(scheme, 2); + for (const value of domain) { + if (value == null) continue; + if (value === true) range.add(t); + else if (value === false) range.add(f); + else return; + } + return [...range]; + } + + const quantitativeSchemes = new Map([ + // diverging + ["brbg", d3.interpolateBrBG], + ["prgn", d3.interpolatePRGn], + ["piyg", d3.interpolatePiYG], + ["puor", d3.interpolatePuOr], + ["rdbu", d3.interpolateRdBu], + ["rdgy", d3.interpolateRdGy], + ["rdylbu", d3.interpolateRdYlBu], + ["rdylgn", d3.interpolateRdYlGn], + ["spectral", d3.interpolateSpectral], + + // reversed diverging (for temperature data) + ["burd", (t) => d3.interpolateRdBu(1 - t)], + ["buylrd", (t) => d3.interpolateRdYlBu(1 - t)], + + // sequential (single-hue) + ["blues", d3.interpolateBlues], + ["greens", d3.interpolateGreens], + ["greys", d3.interpolateGreys], + ["purples", d3.interpolatePurples], + ["reds", d3.interpolateReds], + ["oranges", d3.interpolateOranges], + + // sequential (multi-hue) + ["turbo", d3.interpolateTurbo], + ["viridis", d3.interpolateViridis], + ["magma", d3.interpolateMagma], + ["inferno", d3.interpolateInferno], + ["plasma", d3.interpolatePlasma], + ["cividis", d3.interpolateCividis], + ["cubehelix", d3.interpolateCubehelixDefault], + ["warm", d3.interpolateWarm], + ["cool", d3.interpolateCool], + ["bugn", d3.interpolateBuGn], + ["bupu", d3.interpolateBuPu], + ["gnbu", d3.interpolateGnBu], + ["orrd", d3.interpolateOrRd], + ["pubugn", d3.interpolatePuBuGn], + ["pubu", d3.interpolatePuBu], + ["purd", d3.interpolatePuRd], + ["rdpu", d3.interpolateRdPu], + ["ylgnbu", d3.interpolateYlGnBu], + ["ylgn", d3.interpolateYlGn], + ["ylorbr", d3.interpolateYlOrBr], + ["ylorrd", d3.interpolateYlOrRd], + + // cyclical + ["rainbow", d3.interpolateRainbow], + ["sinebow", d3.interpolateSinebow] + ]); + + function quantitativeScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`); + return quantitativeSchemes.get(s); + } + + const divergingSchemes = new Set([ + "brbg", + "prgn", + "piyg", + "puor", + "rdbu", + "rdgy", + "rdylbu", + "rdylgn", + "spectral", + "burd", + "buylrd" + ]); + + function isDivergingScheme(scheme) { + return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase()); + } + + const flip = (i) => (t) => i(1 - t); + const unit = [0, 1]; + + const interpolators = new Map([ + // numbers + ["number", d3.interpolateNumber], + + // color spaces + ["rgb", d3.interpolateRgb], + ["hsl", d3.interpolateHsl], + ["hcl", d3.interpolateHcl], + ["lab", d3.interpolateLab] + ]); + + function maybeInterpolator(interpolate) { + const i = `${interpolate}`.toLowerCase(); + if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`); + return interpolators.get(i); + } + + function createScaleQ( + key, + scale, + channels, + { + type, + nice, + clamp, + zero, + domain = inferAutoDomain(key, channels), + unknown, + round, + scheme, + interval, + range = registry.get(key) === radius + ? inferRadialRange(channels, domain) + : registry.get(key) === length + ? inferLengthRange(channels, domain) + : registry.get(key) === opacity + ? unit + : undefined, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? d3.interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : type === "cyclical" ? "rainbow" : "turbo") + : round + ? d3.interpolateRound + : d3.interpolateNumber, + reverse + } + ) { + interval = maybeRangeInterval(interval, type); + if (type === "cyclical" || type === "sequential") type = "linear"; // shorthand for color schemes + reverse = !!reverse; + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + if (interpolate.length === 1) { + if (reverse) { + interpolate = flip(interpolate); + reverse = false; + } + if (range === undefined) { + range = Float64Array.from(domain, (_, i) => i / (domain.length - 1)); + if (range.length === 2) range = unit; // optimize common case of [0, 1] + } + scale.interpolate((range === unit ? constant : interpolatePiecewise)(interpolate)); + } else { + scale.interpolate(interpolate); + } + + // If a zero option is specified, we assume that the domain is numeric, and we + // want to ensure that the domain crosses zero. However, note that the domain + // may be reversed (descending) so we shouldn’t assume that the first value is + // smaller than the last; and also it’s possible that the domain has more than + // two values for a “poly” scale. And lastly be careful not to mutate input! + if (zero) { + const [min, max] = d3.extent(domain); + if (min > 0 || max < 0) { + domain = slice(domain); + if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0; + // [2, 1] or [-2, -1] + else domain[0] = 0; // [1, 2] or [-1, -2] + } + } + + if (reverse) domain = d3.reverse(domain); + scale.domain(domain).unknown(unknown); + if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain()); + if (range !== undefined) scale.range(range); + if (clamp) scale.clamp(clamp); + return {type, domain, range, scale, interpolate, interval}; + } + + function maybeNice(nice, type) { + return nice === true ? undefined : typeof nice === "number" ? nice : maybeNiceInterval(nice, type); + } + + function createScaleLinear(key, channels, options) { + return createScaleQ(key, d3.scaleLinear(), channels, options); + } + + function createScaleSqrt(key, channels, options) { + return createScalePow(key, channels, {...options, exponent: 0.5}); + } + + function createScalePow(key, channels, {exponent = 1, ...options}) { + return createScaleQ(key, d3.scalePow().exponent(exponent), channels, {...options, type: "pow"}); + } + + function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) { + return createScaleQ(key, d3.scaleLog().base(base), channels, {...options, domain}); + } + + function createScaleSymlog(key, channels, {constant = 1, ...options}) { + return createScaleQ(key, d3.scaleSymlog().constant(constant), channels, options); + } + + function createScaleQuantile( + key, + channels, + { + range, + quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead + n = quantiles, + scheme = "rdylbu", + domain = inferQuantileDomain(channels), + unknown, + interpolate, + reverse + } + ) { + if (range === undefined) { + range = + interpolate !== undefined + ? d3.quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } + if (domain.length > 0) { + domain = d3.scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles(); + } + return createScaleThreshold(key, channels, {domain, range, reverse, unknown}); + } + + function createScaleQuantize( + key, + channels, + { + range, + n = range === undefined ? 5 : (range = [...range]).length, + scheme = "rdylbu", + domain = inferAutoDomain(key, channels), + unknown, + interpolate, + reverse + } + ) { + const [min, max] = d3.extent(domain); + let thresholds; + if (range === undefined) { + thresholds = d3.ticks(min, max, n); // approximate number of nice, round thresholds + if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound + if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound + n = thresholds.length + 1; + range = + interpolate !== undefined + ? d3.quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } else { + thresholds = d3.quantize(d3.interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range + if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types + } + if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain + return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown}); + } + + function createScaleThreshold( + key, + channels, + { + domain = [0], // explicit thresholds in ascending order + unknown, + scheme = "rdylbu", + interpolate, + range = interpolate !== undefined + ? d3.quantize(interpolate, domain.length + 1) + : registry.get(key) === color + ? ordinalRange(scheme, domain.length + 1) + : undefined, + reverse + } + ) { + domain = arrayify(domain); + const sign = orderof(domain); // preserve descending domain + if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`); + if (reverse) range = d3.reverse(range); // domain ascending, so reverse range + return { + type: "threshold", + scale: d3.scaleThreshold(sign < 0 ? d3.reverse(domain) : domain, range === undefined ? [] : range).unknown(unknown), + domain, + range + }; + } + + function isOrdered(domain, sign) { + for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) { + const s = d3.descending(d, (d = domain[i])); + if (s !== 0 && s !== sign) return false; + } + return true; + } + + function createScaleIdentity() { + return {type: "identity", scale: d3.scaleIdentity()}; + } + + function inferDomain$1(channels, f = finite) { + return channels.length + ? [ + d3.min(channels, ({value}) => (value === undefined ? value : d3.min(value, f))), + d3.max(channels, ({value}) => (value === undefined ? value : d3.max(value, f))) + ] + : [0, 1]; + } + + function inferAutoDomain(key, channels) { + const type = registry.get(key); + return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain$1)(channels); + } + + function inferZeroDomain(channels) { + return [0, channels.length ? d3.max(channels, ({value}) => (value === undefined ? value : d3.max(value, finite))) : 1]; + } + + // We don’t want the upper bound of the radial domain to be zero, as this would + // be degenerate, so we ignore nonpositive values. We also don’t want the + // maximum default radius to exceed 30px. + function inferRadialRange(channels, domain) { + const hint = channels.find(({radius}) => radius !== undefined); + if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins + const h25 = d3.quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : d3.quantile(value, 0.25, positive))); + const range = domain.map((d) => 3 * Math.sqrt(d / h25)); + const k = 30 / d3.max(range); + return k < 1 ? range.map((r) => r * k) : range; + } + + // We want a length scale’s domain to go from zero to a positive value, and to + // treat negative lengths if any as inverted vectors of equivalent magnitude. We + // also don’t want the maximum default length to exceed 60px. + function inferLengthRange(channels, domain) { + const h50 = d3.median(channels, ({value}) => (value === undefined ? NaN : d3.median(value, Math.abs))); + const range = domain.map((d) => (12 * d) / h50); + const k = 60 / d3.max(range); + return k < 1 ? range.map((r) => r * k) : range; + } + + function inferLogDomain(channels) { + for (const {value} of channels) { + if (value !== undefined) { + for (let v of value) { + if (v > 0) return inferDomain$1(channels, positive); + if (v < 0) return inferDomain$1(channels, negative); + } + } + } + return [1, 10]; + } + + function inferQuantileDomain(channels) { + const domain = []; + for (const {value} of channels) { + if (value === undefined) continue; + for (const v of value) domain.push(v); + } + return domain; + } + + function interpolatePiecewise(interpolate) { + return (i, j) => (t) => interpolate(i + t * (j - i)); + } + + function createScaleD( + key, + scale, + transform, + channels, + { + type, + nice, + clamp, + domain = inferDomain$1(channels), + unknown, + pivot = 0, + scheme, + range, + symmetric = true, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? d3.interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : "rdbu") + : d3.interpolateNumber, + reverse + } + ) { + pivot = +pivot; + let [min, max] = domain; + if (d3.descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse); + min = Math.min(min, pivot); + max = Math.max(max, pivot); + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + + // If an explicit range is specified, promote it to a piecewise interpolator. + if (range !== undefined) { + interpolate = + interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : d3.piecewise(interpolate, range); + } + + // Reverse before normalization. + if (reverse) interpolate = flip(interpolate); + + // Normalize the interpolator for symmetric difference around the pivot. + if (symmetric) { + const mid = transform.apply(pivot); + const mindelta = mid - transform.apply(min); + const maxdelta = transform.apply(max) - mid; + if (mindelta < maxdelta) min = transform.invert(mid - maxdelta); + else if (mindelta > maxdelta) max = transform.invert(mid + mindelta); + } + + scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate); + if (clamp) scale.clamp(clamp); + if (nice) scale.nice(nice); + return {type, domain: [min, max], pivot, interpolate, scale}; + } + + function createScaleDiverging(key, channels, options) { + return createScaleD(key, d3.scaleDiverging(), transformIdentity, channels, options); + } + + function createScaleDivergingSqrt(key, channels, options) { + return createScaleDivergingPow(key, channels, {...options, exponent: 0.5}); + } + + function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) { + return createScaleD(key, d3.scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, { + ...options, + type: "diverging-pow" + }); + } + + function createScaleDivergingLog( + key, + channels, + {base = 10, pivot = 1, domain = inferDomain$1(channels, pivot < 0 ? negative : positive), ...options} + ) { + return createScaleD(key, d3.scaleDivergingLog().base((base = +base)), transformLog, channels, { + domain, + pivot, + ...options + }); + } + + function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) { + return createScaleD( + key, + d3.scaleDivergingSymlog().constant((constant = +constant)), + transformSymlog(constant), + channels, + options + ); + } + + const transformIdentity = { + apply(x) { + return x; + }, + invert(x) { + return x; + } + }; + + const transformLog = { + apply: Math.log, + invert: Math.exp + }; + + const transformSqrt = { + apply(x) { + return Math.sign(x) * Math.sqrt(Math.abs(x)); + }, + invert(x) { + return Math.sign(x) * (x * x); + } + }; + + function transformPow(exponent) { + return exponent === 0.5 + ? transformSqrt + : { + apply(x) { + return Math.sign(x) * Math.pow(Math.abs(x), exponent); + }, + invert(x) { + return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent); + } + }; + } + + function transformSymlog(constant) { + return { + apply(x) { + return Math.sign(x) * Math.log1p(Math.abs(x / constant)); + }, + invert(x) { + return Math.sign(x) * Math.expm1(Math.abs(x)) * constant; + } + }; + } + + function createScaleT(key, scale, channels, options) { + return createScaleQ(key, scale, channels, options); + } + + function createScaleTime(key, channels, options) { + return createScaleT(key, d3.scaleTime(), channels, options); + } + + function createScaleUtc(key, channels, options) { + return createScaleT(key, d3.scaleUtc(), channels, options); + } + + // This denotes an implicitly ordinal color scale: the scale type was not set, + // but the associated values are strings or booleans. If the associated defined + // values are entirely boolean, the range will default to greys. You can opt out + // of this by setting the type explicitly. + const ordinalImplicit = Symbol("ordinal"); + + function createScaleO(key, scale, channels, {type, interval, domain, range, reverse, hint}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + if (type === "categorical" || type === ordinalImplicit) type = "ordinal"; // shorthand for color schemes + if (reverse) domain = d3.reverse(domain); + scale.domain(domain); + if (range !== undefined) { + // If the range is specified as a function, pass it the domain. + if (typeof range === "function") range = range(domain); + scale.range(range); + } + return {type, domain, range, scale, hint, interval}; + } + + function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + let hint; + if (registry.get(key) === symbol) { + hint = inferSymbolHint(channels); + range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol); + } else if (registry.get(key) === color) { + if (range === undefined && (type === "ordinal" || type === ordinalImplicit)) { + range = maybeBooleanRange(domain, scheme); + if (range !== undefined) scheme = undefined; // Don’t re-apply scheme. + } + if (scheme === undefined && range === undefined) { + scheme = type === "ordinal" ? "turbo" : "tableau10"; + } + if (scheme !== undefined) { + if (range !== undefined) { + const interpolate = quantitativeScheme(scheme); + const t0 = range[0], + d = range[1] - range[0]; + range = ({length: n}) => d3.quantize((t) => interpolate(t0 + d * t), n); + } else { + range = ordinalScheme(scheme); + } + } + } + if (unknown === d3.scaleImplicit) { + throw new Error(`implicit unknown on ${key} scale is not supported`); + } + return createScaleO(key, d3.scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint}); + } + + function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) { + return maybeRound(d3.scalePoint().align(align).padding(padding), channels, options, key); + } + + function createScaleBand( + key, + channels, + { + align = 0.5, + padding = 0.1, + paddingInner = padding, + paddingOuter = key === "fx" || key === "fy" ? 0 : padding, + ...options + } + ) { + return maybeRound( + d3.scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter), + channels, + options, + key + ); + } + + function maybeRound(scale, channels, options, key) { + let {round} = options; + if (round !== undefined) scale.round((round = !!round)); + scale = createScaleO(key, scale, channels, options); + scale.round = round; // preserve for autoScaleRound + return scale; + } + + function inferDomain(channels, interval, key) { + const values = new d3.InternSet(); + for (const {value, domain} of channels) { + if (domain !== undefined) return domain(); // see channelDomain + if (value === undefined) continue; + for (const v of value) values.add(v); + } + if (interval !== undefined) { + const [min, max] = d3.extent(values).map(interval.floor, interval); + return interval.range(min, interval.offset(max)); + } + if (values.size > 10e3 && registry.get(key) === position) { + throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`); + } + return d3.sort(values, ascendingDefined); + } + + // If all channels provide a consistent hint, propagate it to the scale. + function inferHint(channels, key) { + let value; + for (const {hint} of channels) { + const candidate = hint?.[key]; + if (candidate === undefined) continue; // no hint here + if (value === undefined) value = candidate; + // first hint + else if (value !== candidate) return; // inconsistent hint + } + return value; + } + + function inferSymbolHint(channels) { + return { + fill: inferHint(channels, "fill"), + stroke: inferHint(channels, "stroke") + }; + } + + function inferSymbolRange(hint) { + return isNoneish(hint.fill) ? d3.symbolsStroke : d3.symbolsFill; + } + + function normalizeScale(key, scale, hint) { + return createScale(key, hint === undefined ? undefined : [{hint}], {...scale}); + } + + function createScale(key, channels = [], options = {}) { + const type = inferScaleType(key, channels, options); + + // Warn for common misuses of implicit ordinal scales. We disable this test if + // you specify a scale interval or if you set the domain or range explicitly, + // since setting the domain or range (typically with a cardinality of more than + // two) is another indication that you intended for the scale to be ordinal; we + // also disable it for facet scales since these are always band scales. + if ( + options.type === undefined && + options.domain === undefined && + options.range === undefined && + options.interval == null && + key !== "fx" && + key !== "fy" && + isOrdinalScale({type}) + ) { + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isTemporal)) + warn( + `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isTemporalString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isNumericString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${formatScaleType( + type + )}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + } + + options.type = type; // Mutates input! + + // Once the scale type is known, coerce the associated channel values and any + // explicitly-specified domain to the expected type. + switch (type) { + case "diverging": + case "diverging-sqrt": + case "diverging-pow": + case "diverging-log": + case "diverging-symlog": + case "cyclical": + case "sequential": + case "linear": + case "sqrt": + case "threshold": + case "quantile": + case "pow": + case "log": + case "symlog": + options = coerceType(channels, options, coerceNumbers); + break; + case "identity": + switch (registry.get(key)) { + case position: + options = coerceType(channels, options, coerceNumbers); + break; + case symbol: + options = coerceType(channels, options, coerceSymbols); + break; + } + break; + case "utc": + case "time": + options = coerceType(channels, options, coerceDates); + break; + } + + switch (type) { + case "diverging": + return createScaleDiverging(key, channels, options); + case "diverging-sqrt": + return createScaleDivergingSqrt(key, channels, options); + case "diverging-pow": + return createScaleDivergingPow(key, channels, options); + case "diverging-log": + return createScaleDivergingLog(key, channels, options); + case "diverging-symlog": + return createScaleDivergingSymlog(key, channels, options); + case "categorical": + case "ordinal": + case ordinalImplicit: + return createScaleOrdinal(key, channels, options); + case "cyclical": + case "sequential": + case "linear": + return createScaleLinear(key, channels, options); + case "sqrt": + return createScaleSqrt(key, channels, options); + case "threshold": + return createScaleThreshold(key, channels, options); + case "quantile": + return createScaleQuantile(key, channels, options); + case "quantize": + return createScaleQuantize(key, channels, options); + case "pow": + return createScalePow(key, channels, options); + case "log": + return createScaleLog(key, channels, options); + case "symlog": + return createScaleSymlog(key, channels, options); + case "utc": + return createScaleUtc(key, channels, options); + case "time": + return createScaleTime(key, channels, options); + case "point": + return createScalePoint(key, channels, options); + case "band": + return createScaleBand(key, channels, options); + case "identity": + return registry.get(key) === position ? createScaleIdentity() : {type: "identity"}; + case undefined: + return; + default: + throw new Error(`unknown scale type: ${type}`); + } + } + + function formatScaleType(type) { + return typeof type === "symbol" ? type.description : type; + } + + // A special type symbol when the x and y scales are replaced with a projection. + const typeProjection = {toString: () => "projection"}; + + function inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) { + // The facet scales are always band scales; this cannot be changed. + if (key === "fx" || key === "fy") return "band"; + + // If a projection is specified, the x- and y-scales are disabled; these + // channels will be projected rather than scaled. (But still check that none + // of the associated channels are incompatible with a projection.) + if ((key === "x" || key === "y") && projection != null) type = typeProjection; + + // If a channel dictates a scale type, make sure that it is consistent with + // the user-specified scale type (if any) and all other channels. For example, + // barY requires x to be a band scale and disallows any other scale type. + for (const {type: t} of channels) { + if (t === undefined) continue; + else if (type === undefined) type = t; + else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`); + } + + // If the scale, a channel, or user specified a (consistent) type, return it. + if (type === typeProjection) return; + if (type !== undefined) return type; + + // If there’s no data (and no type) associated with this scale, don’t create a scale. + if (domain === undefined && !channels.some(({value}) => value !== undefined)) return; + + // Some scales have default types. + const kind = registry.get(key); + if (kind === radius) return "sqrt"; + if (kind === opacity || kind === length) return "linear"; + if (kind === symbol) return "ordinal"; + + // If the domain or range has more than two values, assume it’s ordinal. You + // can still use a “piecewise” (or “polylinear”) scale, but you must set the + // type explicitly. + if ((domain || range || []).length > 2) return asOrdinalType(kind); + + // Otherwise, infer the scale type from the data! Prefer the domain, if + // present, over channels. (The domain and channels should be consistently + // typed, and the domain is more explicit and typically much smaller.) We only + // check the first defined value for expedience and simplicity; we expect + // that the types are consistent. + if (domain !== undefined) { + if (isOrdinal(domain)) return asOrdinalType(kind); + if (isTemporal(domain)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; + } + + // If any channel is ordinal or temporal, it takes priority. + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isOrdinal)) return asOrdinalType(kind); + if (values.some(isTemporal)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; + } + + // Positional scales default to a point scale instead of an ordinal scale. + function asOrdinalType(kind) { + switch (kind) { + case position: + return "point"; + case color: + return ordinalImplicit; + default: + return "ordinal"; + } + } + + function isOrdinalScale({type}) { + return type === "ordinal" || type === "point" || type === "band" || type === ordinalImplicit; + } + + function isThresholdScale({type}) { + return type === "threshold"; + } + + // Mutates channel.value! + function coerceType(channels, {domain, ...options}, coerceValues) { + for (const c of channels) { + if (c.value !== undefined) { + c.value = coerceValues(c.value); + } + } + return { + domain: domain === undefined ? domain : coerceValues(domain), + ...options + }; + } + + function coerceSymbols(values) { + return map(values, maybeSymbol); + } + + function memoize1(compute) { + let cacheValue, cacheKeys; + return (...keys) => { + if (cacheKeys?.length !== keys.length || cacheKeys.some((k, i) => k !== keys[i])) { + cacheKeys = keys; + cacheValue = compute(...keys); + } + return cacheValue; + }; + } + + const numberFormat = memoize1((locale) => { + return new Intl.NumberFormat(locale); + }); + + function formatNumber(locale = "en-US") { + const format = numberFormat(locale); + return (i) => (i != null && !isNaN(i) ? format.format(i) : undefined); + } + + function formatIsoDate(date) { + return format(date, "Invalid Date"); + } + + function formatAuto(locale = "en-US") { + const number = formatNumber(locale); + return (v) => (v instanceof Date ? formatIsoDate : typeof v === "number" ? number : string)(v); + } + + // TODO When Plot supports a top-level locale option, this should be removed + // because it lacks context to know which locale to use; formatAuto should be + // used instead whenever possible. + formatAuto(); + + function impliedString(value, impliedValue) { + if ((value = string(value)) !== impliedValue) return value; + } + + // https://www.w3.org/TR/CSS21/grammar.html + const validClassName = + /^-?([_a-z]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])([_a-z0-9-]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])*$/i; + + function maybeClassName(name) { + // The default should be changed whenever the default styles are changed, so + // as to avoid conflict when multiple versions of Plot are on the page. + if (name === undefined) return "plot-d6a7b5"; + name = `${name}`; + if (!validClassName.test(name)) throw new Error(`invalid class name: ${name}`); + return name; + } + + function applyInlineStyles(selection, style) { + if (typeof style === "string") { + selection.property("style", style); + } else if (style != null) { + for (const element of selection) { + Object.assign(element.style, style); + } + } + } + + function inferFontVariant(scale) { + return isOrdinalScale(scale) && scale.interval === undefined ? undefined : "tabular-nums"; + } + + // D3 doesn’t provide a tick format for ordinal scales; we want shorthand when + // an ordinal domain is numbers or dates, and we want null to mean the empty + // string, not the default identity format. TODO Remove this in favor of the + // axis mark’s inferTickFormat. + function maybeAutoTickFormat(tickFormat, domain) { + return tickFormat === undefined + ? isTemporal(domain) + ? formatIsoDate + : string + : typeof tickFormat === "function" + ? tickFormat + : (typeof tickFormat === "string" ? (isTemporal(domain) ? d3.utcFormat : d3.format) : constant)(tickFormat); + } + + function legendRamp(color, options) { + let { + label = color.label, + tickSize = 6, + width = 240, + height = 44 + tickSize, + marginTop = 18, + marginRight = 0, + marginBottom = 16 + tickSize, + marginLeft = 0, + style, + ticks = (width - marginLeft - marginRight) / 64, + tickFormat, + fontVariant = inferFontVariant(color), + round = true, + opacity, + className + } = options; + const context = createContext(options); + className = maybeClassName(className); + opacity = maybeNumberChannel(opacity)[1]; + if (tickFormat === null) tickFormat = () => null; + + const svg = create("svg", context) + .attr("class", `${className}-ramp`) + .attr("font-family", "system-ui, sans-serif") + .attr("font-size", 10) + .attr("width", width) + .attr("height", height) + .attr("viewBox", `0 0 ${width} ${height}`) + .call((svg) => + // Warning: if you edit this, change defaultClassName. + svg.append("style").text( + `.${className}-ramp { + display: block; + background: white; + height: auto; + height: intrinsic; + max-width: 100%; + overflow: visible; +} +.${className}-ramp text { + white-space: pre; +}` + ) + ) + .call(applyInlineStyles, style); + + let tickAdjust = (g) => g.selectAll(".tick line").attr("y1", marginTop + marginBottom - height); + + let x; + + // Some D3 scales use scale.interpolate, some scale.interpolator, and some + // scale.round; this normalizes the API so it works with all scale types. + const applyRange = round ? (x, range) => x.rangeRound(range) : (x, range) => x.range(range); + + const {type, domain, range, interpolate, scale, pivot} = color; + + // Continuous + if (interpolate) { + // Often interpolate is a “fixed” interpolator on the [0, 1] interval, as + // with a built-in color scheme, but sometimes it is a function that takes + // two arguments and is used in conjunction with the range. + const interpolator = + range === undefined + ? interpolate + : d3.piecewise(interpolate.length === 1 ? interpolatePiecewise(interpolate) : interpolate, range); + + // Construct a D3 scale of the same type, but with a range that evenly + // divides the horizontal extent of the legend. (In the common case, the + // domain.length is two, and so the range is simply the extent.) For a + // diverging scale, we need an extra point in the range for the pivot such + // that the pivot is always drawn in the middle. + x = applyRange( + scale.copy(), + d3.quantize( + d3.interpolateNumber(marginLeft, width - marginRight), + Math.min(domain.length + (pivot !== undefined), range === undefined ? Infinity : range.length) + ) + ); + + // Construct a 256×1 canvas, filling each pixel using the interpolator. + const n = 256; + const canvas = context.document.createElement("canvas"); + canvas.width = n; + canvas.height = 1; + const context2 = canvas.getContext("2d"); + for (let i = 0, j = n - 1; i < n; ++i) { + context2.fillStyle = interpolator(i / j); + context2.fillRect(i, 0, 1, 1); + } + + svg + .append("image") + .attr("opacity", opacity) + .attr("x", marginLeft) + .attr("y", marginTop) + .attr("width", width - marginLeft - marginRight) + .attr("height", height - marginTop - marginBottom) + .attr("preserveAspectRatio", "none") + .attr("xlink:href", canvas.toDataURL()); + } + + // Threshold + else if (type === "threshold") { + const thresholds = domain; + + const thresholdFormat = + tickFormat === undefined ? (d) => d : typeof tickFormat === "string" ? d3.format(tickFormat) : tickFormat; + + // Construct a linear scale with evenly-spaced ticks for each of the + // thresholds; the domain extends one beyond the threshold extent. + x = applyRange(d3.scaleLinear().domain([-1, range.length - 1]), [marginLeft, width - marginRight]); + + svg + .append("g") + .attr("fill-opacity", opacity) + .selectAll() + .data(range) + .enter() + .append("rect") + .attr("x", (d, i) => x(i - 1)) + .attr("y", marginTop) + .attr("width", (d, i) => x(i) - x(i - 1)) + .attr("height", height - marginTop - marginBottom) + .attr("fill", (d) => d); + + ticks = map(thresholds, (_, i) => i); + tickFormat = (i) => thresholdFormat(thresholds[i], i); + } + + // Ordinal (hopefully!) + else { + x = applyRange(d3.scaleBand().domain(domain), [marginLeft, width - marginRight]); + + svg + .append("g") + .attr("fill-opacity", opacity) + .selectAll() + .data(domain) + .enter() + .append("rect") + .attr("x", x) + .attr("y", marginTop) + .attr("width", Math.max(0, x.bandwidth() - 1)) + .attr("height", height - marginTop - marginBottom) + .attr("fill", scale); + + tickAdjust = () => {}; + } + + svg + .append("g") + .attr("transform", `translate(0,${height - marginBottom})`) + .call( + d3.axisBottom(x) + .ticks(Array.isArray(ticks) ? null : ticks, typeof tickFormat === "string" ? tickFormat : undefined) + .tickFormat(typeof tickFormat === "function" ? tickFormat : undefined) + .tickSize(tickSize) + .tickValues(Array.isArray(ticks) ? ticks : null) + ) + .attr("font-size", null) + .attr("font-family", null) + .attr("font-variant", impliedString(fontVariant, "normal")) + .call(tickAdjust) + .call((g) => g.select(".domain").remove()); + + if (label !== undefined) { + svg + .append("text") + .attr("x", marginLeft) + .attr("y", marginTop - 6) + .attr("fill", "currentColor") // TODO move to stylesheet? + .attr("font-weight", "bold") + .text(label); + } + + return svg.node(); + } + + function maybeScale(scale, key) { + if (key == null) return key; + const s = scale(key); + if (!s) throw new Error(`scale not found: ${key}`); + return s; + } + + function legendSwatches(color, {opacity, ...options} = {}) { + if (!isOrdinalScale(color) && !isThresholdScale(color)) + throw new Error(`swatches legend requires ordinal or threshold color scale (not ${color.type})`); + return legendItems(color, options, (selection, scale, width, height) => + selection + .append("svg") + .attr("width", width) + .attr("height", height) + .attr("fill", scale.scale) + .attr("fill-opacity", maybeNumberChannel(opacity)[1]) + .append("rect") + .attr("width", "100%") + .attr("height", "100%") + ); + } + + function legendSymbols( + symbol, + { + fill = symbol.hint?.fill !== undefined ? symbol.hint.fill : "none", + fillOpacity = 1, + stroke = symbol.hint?.stroke !== undefined ? symbol.hint.stroke : isNoneish(fill) ? "currentColor" : "none", + strokeOpacity = 1, + strokeWidth = 1.5, + r = 4.5, + ...options + } = {}, + scale + ) { + const [vf, cf] = maybeColorChannel(fill); + const [vs, cs] = maybeColorChannel(stroke); + const sf = maybeScale(scale, vf); + const ss = maybeScale(scale, vs); + const size = r * r * Math.PI; + fillOpacity = maybeNumberChannel(fillOpacity)[1]; + strokeOpacity = maybeNumberChannel(strokeOpacity)[1]; + strokeWidth = maybeNumberChannel(strokeWidth)[1]; + return legendItems(symbol, options, (selection, scale, width, height) => + selection + .append("svg") + .attr("viewBox", "-8 -8 16 16") + .attr("width", width) + .attr("height", height) + .attr("fill", vf === "color" ? (d) => sf.scale(d) : cf) + .attr("fill-opacity", fillOpacity) + .attr("stroke", vs === "color" ? (d) => ss.scale(d) : cs) + .attr("stroke-opacity", strokeOpacity) + .attr("stroke-width", strokeWidth) + .append("path") + .attr("d", (d) => { + const p = d3.pathRound(); + symbol.scale(d).draw(p, size); + return p; + }) + ); + } + + function legendItems(scale, options = {}, swatch) { + let { + columns, + tickFormat, + fontVariant = inferFontVariant(scale), + // TODO label, + swatchSize = 15, + swatchWidth = swatchSize, + swatchHeight = swatchSize, + marginLeft = 0, + className, + style, + width + } = options; + const context = createContext(options); + className = maybeClassName(className); + tickFormat = maybeAutoTickFormat(tickFormat, scale.domain); + + const swatches = create("div", context).attr( + "class", + `${className}-swatches ${className}-swatches-${columns != null ? "columns" : "wrap"}` + ); + + let extraStyle; + + if (columns != null) { + extraStyle = `.${className}-swatches-columns .${className}-swatch { + display: flex; + align-items: center; + break-inside: avoid; + padding-bottom: 1px; +} +.${className}-swatches-columns .${className}-swatch::before { + flex-shrink: 0; +} +.${className}-swatches-columns .${className}-swatch-label { + white-space: nowrap; + overflow: hidden; + text-overflow: ellipsis; +}`; + + swatches + .style("columns", columns) + .selectAll() + .data(scale.domain) + .enter() + .append("div") + .attr("class", `${className}-swatch`) + .call(swatch, scale, swatchWidth, swatchHeight) + .call((item) => + item.append("div").attr("class", `${className}-swatch-label`).attr("title", tickFormat).text(tickFormat) + ); + } else { + extraStyle = `.${className}-swatches-wrap { + display: flex; + align-items: center; + min-height: 33px; + flex-wrap: wrap; +} +.${className}-swatches-wrap .${className}-swatch { + display: inline-flex; + align-items: center; + margin-right: 1em; +}`; + + swatches + .selectAll() + .data(scale.domain) + .enter() + .append("span") + .attr("class", `${className}-swatch`) + .call(swatch, scale, swatchWidth, swatchHeight) + .append(function () { + return this.ownerDocument.createTextNode(tickFormat.apply(this, arguments)); + }); + } + + return swatches + .call((div) => + div.insert("style", "*").text( + `.${className}-swatches { + font-family: system-ui, sans-serif; + font-size: 10px; + margin-bottom: 0.5em; +} +.${className}-swatch > svg { + margin-right: 0.5em; + overflow: visible; +} +${extraStyle}` + ) + ) + .style("margin-left", marginLeft ? `${+marginLeft}px` : null) + .style("width", width === undefined ? null : `${+width}px`) + .style("font-variant", impliedString(fontVariant, "normal")) + .call(applyInlineStyles, style) + .node(); + } + + const legendRegistry = new Map([ + ["symbol", legendSymbols], + ["color", legendColor], + ["opacity", legendOpacity] + ]); + + function legend(options = {}) { + for (const [key, value] of legendRegistry) { + const scale = options[key]; + if (isScaleOptions(scale)) { + // e.g., ignore {color: "red"} + const context = createContext(options); + let hint; + // For symbol legends, pass a hint to the symbol scale. + if (key === "symbol") { + const {fill, stroke = fill === undefined && isScaleOptions(options.color) ? "color" : undefined} = options; + hint = {fill, stroke}; + } + return value(normalizeScale(key, scale, hint), legendOptions(context, scale, options), (key) => + isScaleOptions(options[key]) ? normalizeScale(key, options[key]) : null + ); + } + } + throw new Error("unknown legend type; no scale found"); + } + + function legendOptions({className, ...context}, {label, ticks, tickFormat} = {}, options) { + return inherit(options, {className, ...context}, {label, ticks, tickFormat}); + } + + function legendColor(color, {legend = true, ...options}) { + if (legend === true) legend = color.type === "ordinal" ? "swatches" : "ramp"; + if (color.domain === undefined) return; + switch (`${legend}`.toLowerCase()) { + case "swatches": + return legendSwatches(color, options); + case "ramp": + return legendRamp(color, options); + default: + throw new Error(`unknown legend type: ${legend}`); + } + } + + function legendOpacity({type, interpolate, ...scale}, {legend = true, color = d3.rgb(0, 0, 0), ...options}) { + if (!interpolate) throw new Error(`${type} opacity scales are not supported`); + if (legend === true) legend = "ramp"; + if (`${legend}`.toLowerCase() !== "ramp") throw new Error(`${legend} opacity legends are not supported`); + return legendColor({type, ...scale, interpolate: interpolateOpacity(color)}, {legend, ...options}); + } + + function interpolateOpacity(color) { + const {r, g, b} = d3.rgb(color) || d3.rgb(0, 0, 0); // treat invalid color as black + return (t) => `rgba(${r},${g},${b},${t})`; + } + + var DEFAULT_SELECTOR = '#ch-plugin-legend'; + var defaultOptions = { + // Whether to display the legend + enabled: true, + itemSelector: null, + label: null, + width: 130 + }; + var Legend = /*#__PURE__*/function () { + function Legend(calendar) { + _classCallCheck(this, Legend); + this.name = 'Legend'; + this.calendar = calendar; + this.root = null; + this.shown = false; + this.options = defaultOptions; + } + _createClass(Legend, [{ + key: "setup", + value: function setup(pluginOptions) { + this.options = Object.assign(Object.assign({}, defaultOptions), pluginOptions); + } + }, { + key: "paint", + value: function paint() { + var scaleOptions = this.calendar.options.options.scale; + var _this$options = this.options, + enabled = _this$options.enabled, + itemSelector = _this$options.itemSelector; + if (!enabled || itemSelector && d3Selection.select(itemSelector).empty()) { + return this.destroy(); + } + this.shown = true; + this.root = d3Selection.select(itemSelector || this.calendar.options.options.itemSelector); + if (this.root.select(DEFAULT_SELECTOR).empty()) { + this.root = this.root.append('div').attr('id', DEFAULT_SELECTOR.slice(1)); + } else { + this.root = this.root.select(DEFAULT_SELECTOR); + } + // @ts-ignore + var node = legend(Object.assign(Object.assign({}, scaleOptions), this.options)); + this.root.selectAll('*').remove(); + this.root.append(function () { + return node; + }); + return Promise.resolve(); + } + }, { + key: "destroy", + value: function destroy() { + if (this.root !== null) { + this.root.remove(); + this.root = null; + } + return Promise.resolve(); + } + }]); + return Legend; + }(); + + return Legend; + +})); diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.esm.js b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.esm.js new file mode 100644 index 0000000..949fcd8 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.esm.js @@ -0,0 +1 @@ +import{select as t}from"d3-selection";import{ascending as n,timeSecond as e,timeMinute as r,timeHour as o,timeDay as i,timeWeek as a,timeMonth as c,timeYear as u,timeMonday as s,timeTuesday as l,timeWednesday as f,timeThursday as p,timeFriday as d,timeSaturday as h,timeSunday as y,utcSecond as g,utcMinute as v,utcHour as m,utcDay as w,utcWeek as b,utcMonth as S,utcYear as j,utcMonday as $,utcTuesday as O,utcWednesday as k,utcThursday as E,utcFriday as M,utcSaturday as x,utcSunday as T,color as N,descending as P,range as C,symbolAsterisk as R,symbolCircle as I,symbolCross as A,symbolDiamond as D,symbolDiamond2 as L,symbolPlus as q,symbolSquare as F,symbolSquare2 as _,symbolStar as U,symbolTimes as z,symbolTriangle as W,symbolTriangle2 as B,symbolWye as G,geoPath as H,geoTransform as V,geoClipRectangle as Y,geoTransverseMercator as J,geoStereographic as K,geoOrthographic as X,geoMercator as Z,geoGnomonic as Q,geoEquirectangular as tt,geoEqualEarth as nt,geoAzimuthalEquidistant as et,geoAzimuthalEqualArea as rt,geoAlbersUsa as ot,geoConicEquidistant as it,geoConicEqualArea as at,geoConicConformal as ct,geoAlbers as ut,select as st,creator as lt,schemeAccent as ft,schemeCategory10 as pt,schemeDark2 as dt,schemePaired as ht,schemePastel1 as yt,schemePastel2 as gt,schemeSet1 as vt,schemeSet2 as mt,schemeSet3 as wt,schemeTableau10 as bt,quantize as St,interpolateBrBG as jt,interpolatePRGn as $t,interpolatePiYG as Ot,interpolatePuOr as kt,interpolateRdBu as Et,interpolateRdGy as Mt,interpolateRdYlBu as xt,interpolateRdYlGn as Tt,interpolateSpectral as Nt,interpolateBlues as Pt,interpolateGreens as Ct,interpolateGreys as Rt,interpolatePurples as It,interpolateReds as At,interpolateOranges as Dt,interpolateTurbo as Lt,interpolateViridis as qt,interpolateMagma as Ft,interpolateInferno as _t,interpolatePlasma as Ut,interpolateCividis as zt,interpolateCubehelixDefault as Wt,interpolateWarm as Bt,interpolateCool as Gt,interpolateBuGn as Ht,interpolateBuPu as Vt,interpolateGnBu as Yt,interpolateOrRd as Jt,interpolatePuBuGn as Kt,interpolatePuBu as Xt,interpolatePuRd as Zt,interpolateRdPu as Qt,interpolateYlGnBu as tn,interpolateYlGn as nn,interpolateYlOrBr as en,interpolateYlOrRd as rn,interpolateRainbow as on,interpolateSinebow as an,schemeBrBG as cn,schemePRGn as un,schemePiYG as sn,schemePuOr as ln,schemeRdBu as fn,schemeRdGy as pn,schemeRdYlBu as dn,schemeRdYlGn as hn,schemeSpectral as yn,schemeBlues as gn,schemeGreens as vn,schemeGreys as mn,schemeOranges as wn,schemePurples as bn,schemeReds as Sn,schemeBuGn as jn,schemeBuPu as $n,schemeGnBu as On,schemeOrRd as kn,schemePuBu as En,schemePuBuGn as Mn,schemePuRd as xn,schemeRdPu as Tn,schemeYlGn as Nn,schemeYlGnBu as Pn,schemeYlOrBr as Cn,schemeYlOrRd as Rn,scaleLinear as In,scalePow as An,scaleLog as Dn,scaleSymlog as Ln,scaleQuantile as qn,extent as Fn,ticks as _n,interpolateNumber as Un,reverse as zn,scaleThreshold as Wn,scaleIdentity as Bn,max as Gn,interpolateRgb as Hn,interpolateRound as Vn,min as Yn,quantile as Jn,median as Kn,interpolateHsl as Xn,interpolateHcl as Zn,interpolateLab as Qn,scaleDiverging as te,scaleDivergingPow as ne,scaleDivergingLog as ee,scaleDivergingSymlog as re,piecewise as oe,scaleTime as ie,scaleUtc as ae,scaleImplicit as ce,scaleOrdinal as ue,scalePoint as se,scaleBand as le,InternSet as fe,sort as pe,symbolsStroke as de,symbolsFill as he,utcFormat as ye,format as ge,axisBottom as ve,pathRound as me,rgb as we}from"d3";function be(t,n){for(var e=0;e0&&ur[0]<4?1:+(ur[0]+ur[1])),!sr&&qr&&(!(ur=qr.match(/Edge\/(\d+)/))||ur[1]>=74)&&(ur=qr.match(/Chrome\/(\d+)/))&&(sr=+ur[1]);var Wr=sr,Br=Wr,Gr=je,Hr=Ze.String,Vr=!!Object.getOwnPropertySymbols&&!Gr((function(){var t=Symbol("symbol detection");return!Hr(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&Br&&Br<41})),Yr=Vr&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,Jr=Ir,Kr=Ke,Xr=Ar,Zr=Object,Qr=Yr?function(t){return"symbol"==typeof t}:function(t){var n=Jr("Symbol");return Kr(n)&&Xr(n.prototype,Zr(t))},to=String,no=function(t){try{return to(t)}catch(t){return"Object"}},eo=Ke,ro=no,oo=TypeError,io=function(t){if(eo(t))return t;throw new oo(ro(t)+" is not a function")},ao=io,co=Ne,uo=function(t,n){var e=t[n];return co(e)?void 0:ao(e)},so=Pr,lo=Ke,fo=gr,po=TypeError,ho={exports:{}},yo=or;(ho.exports=function(t,n){return yo[t]||(yo[t]=void 0!==n?n:{})})("versions",[]).push({version:"3.34.0",mode:"global",copyright:"© 2014-2023 Denis Pushkarev (zloirock.ru)",license:"https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE",source:"https://github.com/zloirock/core-js"});var go=ho.exports,vo=Te,mo=0,wo=Math.random(),bo=vo(1..toString),So=function(t){return"Symbol("+(void 0===t?"":t)+")_"+bo(++mo+wo,36)},jo=go,$o=Fe,Oo=So,ko=Vr,Eo=Yr,Mo=Ze.Symbol,xo=jo("wks"),To=Eo?Mo.for||Mo:Mo&&Mo.withoutSetter||Oo,No=function(t){return $o(xo,t)||(xo[t]=ko&&$o(Mo,t)?Mo[t]:To("Symbol."+t)),xo[t]},Po=Pr,Co=gr,Ro=Qr,Io=uo,Ao=function(t,n){var e,r;if("string"===n&&lo(e=t.toString)&&!fo(r=so(e,t)))return r;if(lo(e=t.valueOf)&&!fo(r=so(e,t)))return r;if("string"!==n&&lo(e=t.toString)&&!fo(r=so(e,t)))return r;throw new po("Can't convert object to primitive value")},Do=TypeError,Lo=No("toPrimitive"),qo=function(t,n){if(!Co(t)||Ro(t))return t;var e,r=Io(t,Lo);if(r){if(void 0===n&&(n="default"),e=Po(r,t,n),!Co(e)||Ro(e))return e;throw new Do("Can't convert object to primitive value")}return void 0===n&&(n="number"),Ao(t,n)},Fo=Qr,_o=function(t){var n=qo(t,"string");return Fo(n)?n:n+""},Uo=$e,zo=$r,Wo=Or,Bo=xr,Go=_o,Ho=TypeError,Vo=Object.defineProperty,Yo=Object.getOwnPropertyDescriptor,Jo="enumerable",Ko="configurable",Xo="writable";vr.f=Uo?Wo?function(t,n,e){if(Bo(t),n=Go(n),Bo(e),"function"==typeof t&&"prototype"===n&&"value"in e&&Xo in e&&!e[Xo]){var r=Yo(t,n);r&&r[Xo]&&(t[n]=e.value,e={configurable:Ko in e?e[Ko]:r[Ko],enumerable:Jo in e?e[Jo]:r[Jo],writable:!1})}return Vo(t,n,e)}:Vo:function(t,n,e){if(Bo(t),n=Go(n),Bo(e),zo)try{return Vo(t,n,e)}catch(t){}if("get"in e||"set"in e)throw new Ho("Accessors not supported");return"value"in e&&(t[n]=e.value),t};var Zo,Qo,ti,ni=function(t,n){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:n}},ei=vr,ri=ni,oi=$e?function(t,n,e){return ei.f(t,n,ri(1,e))}:function(t,n,e){return t[n]=e,t},ii=So,ai=go("keys"),ci={},ui=dr,si=Ze,li=gr,fi=oi,pi=Fe,di=or,hi=function(t){return ai[t]||(ai[t]=ii(t))},yi=ci,gi="Object already initialized",vi=si.TypeError,mi=si.WeakMap;if(ui||di.state){var wi=di.state||(di.state=new mi);wi.get=wi.get,wi.has=wi.has,wi.set=wi.set,Zo=function(t,n){if(wi.has(t))throw new vi(gi);return n.facade=t,wi.set(t,n),n},Qo=function(t){return wi.get(t)||{}},ti=function(t){return wi.has(t)}}else{var bi=hi("state");yi[bi]=!0,Zo=function(t,n){if(pi(t,bi))throw new vi(gi);return n.facade=t,fi(t,bi,n),n},Qo=function(t){return pi(t,bi)?t[bi]:{}},ti=function(t){return pi(t,bi)}}var Si={set:Zo,get:Qo,has:ti,enforce:function(t){return ti(t)?Qo(t):Zo(t,{})},getterFor:function(t){return function(n){var e;if(!li(n)||(e=Qo(n)).type!==t)throw new vi("Incompatible receiver, "+t+" required");return e}}},ji=Te,$i=je,Oi=Ke,ki=Fe,Ei=$e,Mi=Ge.CONFIGURABLE,xi=lr,Ti=Si.enforce,Ni=Si.get,Pi=String,Ci=Object.defineProperty,Ri=ji("".slice),Ii=ji("".replace),Ai=ji([].join),Di=Ei&&!$i((function(){return 8!==Ci((function(){}),"length",{value:8}).length})),Li=String(String).split("String"),qi=He.exports=function(t,n,e){"Symbol("===Ri(Pi(n),0,7)&&(n="["+Ii(Pi(n),/^Symbol\(([^)]*)\)/,"$1")+"]"),e&&e.getter&&(n="get "+n),e&&e.setter&&(n="set "+n),(!ki(t,"name")||Mi&&t.name!==n)&&(Ei?Ci(t,"name",{value:n,configurable:!0}):t.name=n),Di&&e&&ki(e,"arity")&&t.length!==e.arity&&Ci(t,"length",{value:e.arity});try{e&&ki(e,"constructor")&&e.constructor?Ei&&Ci(t,"prototype",{writable:!1}):t.prototype&&(t.prototype=void 0)}catch(t){}var r=Ti(t);return ki(r,"source")||(r.source=Ai(Li,"string"==typeof n?n:"")),t};Function.prototype.toString=qi((function(){return Oi(this)&&Ni(this).source||xi(this)}),"toString");var Fi=He.exports,_i=Fi,Ui=vr,zi=function(t,n,e){return e.get&&_i(e.get,n,{getter:!0}),e.set&&_i(e.set,n,{setter:!0}),Ui.f(t,n,e)},Wi=$e,Bi=Ge.EXISTS,Gi=Te,Hi=zi,Vi=Function.prototype,Yi=Gi(Vi.toString),Ji=/function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/,Ki=Gi(Ji.exec);Wi&&!Bi&&Hi(Vi,"name",{configurable:!0,get:function(){try{return Ki(Ji,Yi(this))[1]}catch(t){return""}}});var Xi={},Zi={},Qi={}.propertyIsEnumerable,ta=Object.getOwnPropertyDescriptor,na=ta&&!Qi.call({1:2},1);Zi.f=na?function(t){var n=ta(this,t);return!!n&&n.enumerable}:Qi;var ea=Te,ra=ea({}.toString),oa=ea("".slice),ia=function(t){return oa(ra(t),8,-1)},aa=je,ca=ia,ua=Object,sa=Te("".split),la=aa((function(){return!ua("z").propertyIsEnumerable(0)}))?function(t){return"String"===ca(t)?sa(t,""):ua(t)}:ua,fa=la,pa=Re,da=function(t){return fa(pa(t))},ha=$e,ya=Pr,ga=Zi,va=ni,ma=da,wa=_o,ba=Fe,Sa=$r,ja=Object.getOwnPropertyDescriptor;Xi.f=ha?ja:function(t,n){if(t=ma(t),n=wa(n),Sa)try{return ja(t,n)}catch(t){}if(ba(t,n))return va(!ya(ga.f,t,n),t[n])};var $a=Ke,Oa=vr,ka=Fi,Ea=nr,Ma=function(t,n,e,r){r||(r={});var o=r.enumerable,i=void 0!==r.name?r.name:n;if($a(e)&&ka(e,i,r),r.global)o?t[n]=e:Ea(n,e);else{try{r.unsafe?t[n]&&(o=!0):delete t[n]}catch(t){}o?t[n]=e:Oa.f(t,n,{value:e,enumerable:!1,configurable:!r.nonConfigurable,writable:!r.nonWritable})}return t},xa={},Ta=Math.ceil,Na=Math.floor,Pa=Math.trunc||function(t){var n=+t;return(n>0?Na:Ta)(n)},Ca=function(t){var n=+t;return n!=n||0===n?0:Pa(n)},Ra=Ca,Ia=Math.max,Aa=Math.min,Da=Ca,La=Math.min,qa=function(t){return t>0?La(Da(t),9007199254740991):0},Fa=function(t){return qa(t.length)},_a=da,Ua=function(t,n){var e=Ra(t);return e<0?Ia(e+n,0):Aa(e,n)},za=Fa,Wa=function(t){return function(n,e,r){var o,i=_a(n),a=za(i),c=Ua(r,a);if(t&&e!=e){for(;a>c;)if((o=i[c++])!=o)return!0}else for(;a>c;c++)if((t||c in i)&&i[c]===e)return t||c||0;return!t&&-1}},Ba={includes:Wa(!0),indexOf:Wa(!1)},Ga=Fe,Ha=da,Va=Ba.indexOf,Ya=ci,Ja=Te([].push),Ka=function(t,n){var e,r=Ha(t),o=0,i=[];for(e in r)!Ga(Ya,e)&&Ga(r,e)&&Ja(i,e);for(;n.length>o;)Ga(r,e=n[o++])&&(~Va(i,e)||Ja(i,e));return i},Xa=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],Za=Ka,Qa=Xa.concat("length","prototype");xa.f=Object.getOwnPropertyNames||function(t){return Za(t,Qa)};var tc={};tc.f=Object.getOwnPropertySymbols;var nc=Ir,ec=xa,rc=tc,oc=xr,ic=Te([].concat),ac=nc("Reflect","ownKeys")||function(t){var n=ec.f(oc(t)),e=rc.f;return e?ic(n,e(t)):n},cc=Fe,uc=ac,sc=Xi,lc=vr,fc=je,pc=Ke,dc=/#|\.prototype\./,hc=function(t,n){var e=gc[yc(t)];return e===mc||e!==vc&&(pc(n)?fc(n):!!n)},yc=hc.normalize=function(t){return String(t).replace(dc,".").toLowerCase()},gc=hc.data={},vc=hc.NATIVE="N",mc=hc.POLYFILL="P",wc=hc,bc=Ze,Sc=Xi.f,jc=oi,$c=Ma,Oc=nr,kc=function(t,n,e){for(var r=uc(n),o=lc.f,i=sc.f,a=0;ao;)for(var c,u=Fc(arguments[o++]),s=i?zc(Ac(u),i(u)):Ac(u),l=s.length,f=0;l>f;)c=s[f++],Pc&&!Rc(a,u,c)||(e[c]=u[c]);return e}:_c,Bc=Wc;Mc({target:"Object",stat:!0,arity:2,forced:Object.assign!==Bc},{assign:Bc});var Gc={};Gc[No("toStringTag")]="z";var Hc="[object z]"===String(Gc),Vc=Hc,Yc=Ke,Jc=ia,Kc=No("toStringTag"),Xc=Object,Zc="Arguments"===Jc(function(){return arguments}()),Qc=Vc?Jc:function(t){var n,e,r;return void 0===t?"Undefined":null===t?"Null":"string"==typeof(e=function(t,n){try{return t[n]}catch(t){}}(n=Xc(t),Kc))?e:Zc?Jc(n):"Object"===(r=Jc(n))&&Yc(n.callee)?"Arguments":r},tu=Qc,nu=Hc?{}.toString:function(){return"[object "+tu(this)+"]"};Hc||Ma(Object.prototype,"toString",nu,{unsafe:!0});var eu="process"===ia(Ze.process),ru=Te,ou=io,iu=Ke,au=String,cu=TypeError,uu=function(t,n,e){try{return ru(ou(Object.getOwnPropertyDescriptor(t,n)[e]))}catch(t){}},su=xr,lu=function(t){if("object"==typeof t||iu(t))return t;throw new cu("Can't set "+au(t)+" as a prototype")},fu=Object.setPrototypeOf||("__proto__"in{}?function(){var t,n=!1,e={};try{(t=uu(Object.prototype,"__proto__","set"))(e,[]),n=e instanceof Array}catch(t){}return function(e,r){return su(e),lu(r),n?t(e,r):e.__proto__=r,e}}():void 0),pu=vr.f,du=Fe,hu=No("toStringTag"),yu=Ir,gu=zi,vu=$e,mu=No("species"),wu=Ar,bu=TypeError,Su=Te,ju=je,$u=Ke,Ou=Qc,ku=lr,Eu=function(){},Mu=[],xu=Ir("Reflect","construct"),Tu=/^\s*(?:class|function)\b/,Nu=Su(Tu.exec),Pu=!Tu.test(Eu),Cu=function(t){if(!$u(t))return!1;try{return xu(Eu,Mu,t),!0}catch(t){return!1}},Ru=function(t){if(!$u(t))return!1;switch(Ou(t)){case"AsyncFunction":case"GeneratorFunction":case"AsyncGeneratorFunction":return!1}try{return Pu||!!Nu(Tu,ku(t))}catch(t){return!0}};Ru.sham=!0;var Iu,Au,Du,Lu,qu=!xu||ju((function(){var t;return Cu(Cu.call)||!Cu(Object)||!Cu((function(){t=!0}))||t}))?Ru:Cu,Fu=qu,_u=no,Uu=TypeError,zu=xr,Wu=function(t){if(Fu(t))return t;throw new Uu(_u(t)+" is not a constructor")},Bu=Ne,Gu=No("species"),Hu=Oe,Vu=Function.prototype,Yu=Vu.apply,Ju=Vu.call,Ku="object"==typeof Reflect&&Reflect.apply||(Hu?Ju.bind(Yu):function(){return Ju.apply(Yu,arguments)}),Xu=ia,Zu=Te,Qu=function(t){if("Function"===Xu(t))return Zu(t)},ts=io,ns=Oe,es=Qu(Qu.bind),rs=function(t,n){return ts(t),void 0===n?t:ns?es(t,n):function(){return t.apply(n,arguments)}},os=Ir("document","documentElement"),is=Te([].slice),as=TypeError,cs=/(?:ipad|iphone|ipod).*applewebkit/i.test(Dr),us=Ze,ss=Ku,ls=rs,fs=Ke,ps=Fe,ds=je,hs=os,ys=is,gs=Sr,vs=function(t,n){if(ti;i++)if((c=v(t[i]))&&Zf(op,c))return c;return new rp(!1)}r=Qf(t,o)}for(u=p?t.next:r.next;!(s=Vf(u,r)).done;){try{c=v(s.value)}catch(t){np(r,"throw",t)}if("object"==typeof c&&c&&Zf(op,c))return c}return new rp(!1)},ap=No("iterator"),cp=!1;try{var up=0,sp={next:function(){return{done:!!up++}},return:function(){cp=!0}};sp[ap]=function(){return this},Array.from(sp,(function(){throw 2}))}catch(t){}var lp=sl,fp=function(t,n){try{if(!n&&!cp)return!1}catch(t){return!1}var e=!1;try{var r={};r[ap]=function(){return{next:function(){return{done:e=!0}}}},t(r)}catch(t){}return e},pp=kl.CONSTRUCTOR||!fp((function(t){lp.all(t).then(void 0,(function(){}))})),dp=Pr,hp=io,yp=El,gp=ul,vp=ip;Mc({target:"Promise",stat:!0,forced:pp},{all:function(t){var n=this,e=yp.f(n),r=e.resolve,o=e.reject,i=gp((function(){var e=hp(n.resolve),i=[],a=0,c=1;vp(t,(function(t){var u=a++,s=!1;c++,dp(e,n,t).then((function(t){s||(s=!0,i[u]=t,--c||r(i))}),o)})),--c||r(i)}));return i.error&&o(i.value),e.promise}});var mp=Mc,wp=kl.CONSTRUCTOR,bp=sl,Sp=Ir,jp=Ke,$p=Ma,Op=bp&&bp.prototype;if(mp({target:"Promise",proto:!0,forced:wp,real:!0},{catch:function(t){return this.then(void 0,t)}}),jp(bp)){var kp=Sp("Promise").prototype.catch;Op.catch!==kp&&$p(Op,"catch",kp,{unsafe:!0})}var Ep=Pr,Mp=io,xp=El,Tp=ul,Np=ip;Mc({target:"Promise",stat:!0,forced:pp},{race:function(t){var n=this,e=xp.f(n),r=e.reject,o=Tp((function(){var o=Mp(n.resolve);Np(t,(function(t){Ep(o,n,t).then(e.resolve,r)}))}));return o.error&&r(o.value),e.promise}});var Pp=Pr,Cp=El;Mc({target:"Promise",stat:!0,forced:kl.CONSTRUCTOR},{reject:function(t){var n=Cp.f(this);return Pp(n.reject,void 0,t),n.promise}});var Rp=xr,Ip=gr,Ap=El,Dp=Mc,Lp=kl.CONSTRUCTOR,qp=function(t,n){if(Rp(t),Ip(n)&&n.constructor===t)return n;var e=Ap.f(t);return(0,e.resolve)(n),e.promise};function Fp(t){return null!=t&&!Number.isNaN(t)}function _p(t,e){return+Fp(e)-+Fp(t)||n(t,e)}function Up(t){return isFinite(t)?t:NaN}function zp(t){return t>0&&isFinite(t)?t:NaN}function Wp(t){return t<0&&isFinite(t)?t:NaN}function Bp(t,n){if(t instanceof Date||(t=new Date(+t)),isNaN(t))return"function"==typeof n?n(t):n;const e=t.getUTCHours(),r=t.getUTCMinutes(),o=t.getUTCSeconds(),i=t.getUTCMilliseconds();return`${a=t.getUTCFullYear(),a<0?`-${Gp(-a,6)}`:a>9999?`+${Gp(a,6)}`:Gp(a,4)}-${Gp(t.getUTCMonth()+1,2)}-${Gp(t.getUTCDate(),2)}${e||r||o||i?`T${Gp(e,2)}:${Gp(r,2)}${o||i?`:${Gp(o,2)}${i?`.${Gp(i,3)}`:""}`:""}Z`:""}`;var a}function Gp(t,n){return`${t}`.padStart(n,"0")}Ir("Promise"),Dp({target:"Promise",stat:!0,forced:Lp},{resolve:function(t){return qp(this,t)}});const Hp=/^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/;function Vp(t,n){return Hp.test(t+="")?new Date(t):"function"==typeof n?n(t):n}const Yp=new Map([["second",e],["minute",r],["hour",o],["day",i],["week",a],["month",c],["quarter",c.every(3)],["half",c.every(6)],["year",u],["monday",s],["tuesday",l],["wednesday",f],["thursday",p],["friday",d],["saturday",h],["sunday",y]]),Jp=new Map([["second",g],["minute",v],["hour",m],["day",w],["week",b],["month",S],["quarter",S.every(3)],["half",S.every(6)],["year",j],["monday",$],["tuesday",O],["wednesday",k],["thursday",E],["friday",M],["saturday",x],["sunday",T]]);function Kp(t){const n=Yp.get(`${t}`.toLowerCase());if(!n)throw new Error(`unknown interval: ${t}`);return n}function Xp(t){const n=Jp.get(`${t}`.toLowerCase());if(!n)throw new Error(`unknown interval: ${t}`);return n}const Zp=Object.getPrototypeOf(Uint8Array),Qp=Object.prototype.toString,td=t=>null==t?t:`${t}`,nd=t=>()=>t;function ed(t){return t instanceof Zp?t:sd(t,rd,Float64Array)}function rd(t){return null==t?NaN:Number(t)}function od(t){return sd(t,id)}function id(t){return t instanceof Date&&!isNaN(t)?t:"string"==typeof t?Vp(t):null==t||isNaN(t=+t)?void 0:new Date(t)}function ad(t,n){return void 0===t&&(t=n),null===t?[void 0,"none"]:function(t){return"string"==typeof t&&(t=t.toLowerCase().trim(),"none"===t||"currentcolor"===t||t.startsWith("url(")&&t.endsWith(")")||t.startsWith("var(")&&t.endsWith(")")||null!==N(t))}(t)?[void 0,t]:[t,void 0]}function cd(t,n){return void 0===t&&(t=n),null===t||"number"==typeof t?[void 0,t]:[t,void 0]}function ud(t){return null==t||t instanceof Array||t instanceof Zp?t:Array.from(t)}function sd(t,n,e=Array){return null==t?t:t instanceof e?t.map(n):e.from(t,n)}function ld(t){return t?.toString===Qp}function fd(t){return ld(t)&&(void 0!==t.type||void 0!==t.domain)}function pd(t,n){if(null!=t){if("number"==typeof t){0Math.floor(t*n)/n,offset:t=>(t*n+1)/n,range:(t,e)=>C(Math.ceil(t*n),e*n).map((t=>t/n))}:{floor:t=>Math.floor(t/n)*n,offset:t=>t+n,range:(t,e)=>C(Math.ceil(t/n),e/n).map((t=>t*n))}}if("string"==typeof t)return("time"===n?Kp:Xp)(t);if("function"!=typeof t.floor)throw new Error("invalid interval; missing floor method");if("function"!=typeof t.offset)throw new Error("invalid interval; missing offset method");return t}}function dd(t,n){if((t=pd(t,n))&&"function"!=typeof t.range)throw new Error("invalid interval: missing range method");return t}function hd(t){for(const n of t){if(null==n)continue;const t=typeof n;return"string"===t||"boolean"===t}}function yd(t){for(const n of t)if(null!=n)return n instanceof Date}function gd(t){for(const n of t)if(null!=n)return"string"==typeof n&&isNaN(n)&&Vp(n)}function vd(t){for(const n of t)if(null!=n){if("string"!=typeof n)return!1;if(n.trim())return!isNaN(n)}}function md(t){return null==t||function(t){return/^\s*none\s*$/i.test(t)}(t)}function wd(t){if(null==t)return;const n=t[0],e=t[t.length-1];return P(n,e)}const bd=Symbol("position"),Sd=Symbol("color"),jd=Symbol("radius"),$d=Symbol("length"),Od=Symbol("opacity"),kd=Symbol("symbol"),Ed=new Map([["x",bd],["y",bd],["fx",bd],["fy",bd],["r",jd],["color",Sd],["opacity",Od],["symbol",kd],["length",$d]]),Md=2/Math.sqrt(3),xd=new Map([["asterisk",R],["circle",I],["cross",A],["diamond",D],["diamond2",L],["hexagon",{draw(t,n){const e=Math.sqrt(n/Math.PI),r=e*Md,o=r/2;t.moveTo(0,r),t.lineTo(e,o),t.lineTo(e,-o),t.lineTo(0,-r),t.lineTo(-e,-o),t.lineTo(-e,o),t.closePath()}}],["plus",q],["square",F],["square2",_],["star",U],["times",z],["triangle",W],["triangle2",B],["wye",G]]);function Td(t){if(null==t||function(t){return t&&"function"==typeof t.draw}(t))return t;const n=xd.get(`${t}`.toLowerCase());if(n)return n;throw new Error(`invalid symbol: ${t}`)}function Nd(t){console.warn(t)}const Pd=Math.PI,Cd=2*Pd;function Rd({projection:t,inset:n=0,insetTop:e=n,insetRight:r=n,insetBottom:o=n,insetLeft:i=n}={},a){if(null==t)return;if("function"==typeof t.stream)return t;let c,u,s="frame";if(ld(t)){let n;if(({type:t,domain:u,inset:n,insetTop:e=(void 0!==n?n:e),insetRight:r=(void 0!==n?n:r),insetBottom:o=(void 0!==n?n:o),insetLeft:i=(void 0!==n?n:i),clip:s=s,...c}=t),null==t)return}"function"!=typeof t&&({type:t}=function(t){switch(`${t}`.toLowerCase()){case"albers-usa":return Id(ot,.7463,.4673);case"albers":return Ad(ut,.7463,.4673);case"azimuthal-equal-area":return Id(rt,4,4);case"azimuthal-equidistant":return Id(et,Cd,Cd);case"conic-conformal":return Ad(ct,Cd,Cd);case"conic-equal-area":return Ad(at,6.1702,2.9781);case"conic-equidistant":return Ad(it,7.312,3.6282);case"equal-earth":return Id(nt,5.4133,2.6347);case"equirectangular":return Id(tt,Cd,Pd);case"gnomonic":return Id(Q,3.4641,3.4641);case"identity":return{type:Dd};case"reflect-y":return{type:Ld};case"mercator":return Id(Z,Cd,Cd);case"orthographic":return Id(X,2,2);case"stereographic":return Id(K,2,2);case"transverse-mercator":return Id(J,Cd,Cd);default:throw new Error(`unknown projection type: ${t}`)}}(t));const{width:l,height:f,marginLeft:p,marginRight:d,marginTop:h,marginBottom:y}=a,g=l-p-d-i-r,v=f-h-y-e-o;if(t=t?.({width:g,height:v,clip:s,...c}),null==t)return;s=function(t,n,e,r,o){if(!1===t||null==t||"number"==typeof t)return t=>t;!0===t&&(t="frame");if("frame"===`${t}`.toLowerCase())return Y(n,e,r,o);throw new Error(`unknown projection clip type: ${t}`)}(s,p,h,l-d,f-y);let m,w=p+i,b=h+e;if(null!=u){const[[n,e],[r,o]]=H(t).bounds(u),i=Math.min(g/(r-n),v/(o-e));i>0?(w-=(i*(n+r)-g)/2,b-=(i*(e+o)-v)/2,m=V({point(t,n){this.stream.point(t*i+w,n*i+b)}})):Nd("Warning: the projection could not be fit to the specified domain; using the default scale.")}return m??=0===w&&0===b?Dd():V({point(t,n){this.stream.point(t+w,n+b)}}),{stream:n=>t.stream(m.stream(s(n)))}}function Id(t,n,e){return{type:({width:r,height:o,rotate:i,precision:a=.15,clip:c})=>{const u=t();return null!=a&&u.precision?.(a),null!=i&&u.rotate?.(i),"number"==typeof c&&u.clipAngle?.(c),u.scale(Math.min(r/n,o/e)),u.translate([r/2,o/2]),u},aspectRatio:e/n}}function Ad(t,n,e){const{type:r,aspectRatio:o}=Id(t,n,e);return{type:t=>{const{parallels:n,domain:e,width:o,height:i}=t,a=r(t);return null!=n&&(a.parallels(n),void 0===e&&a.fitSize([o,i],{type:"Sphere"})),a},aspectRatio:o}}const Dd=nd({stream:t=>t}),Ld=nd(V({point(t,n){this.stream.point(t,-n)}}));function qd(t={},n,e){const{document:r=("undefined"!=typeof window?window.document:void 0)}=t;return{document:r,className:e,projection:Rd(t,n)}}function Fd(t,{document:n}){return st(lt(t).call(n.documentElement))}const _d=new Map([["accent",ft],["category10",pt],["dark2",dt],["paired",ht],["pastel1",yt],["pastel2",gt],["set1",vt],["set2",mt],["set3",wt],["tableau10",bt],["brbg",zd(cn,jt)],["prgn",zd(un,$t)],["piyg",zd(sn,Ot)],["puor",zd(ln,kt)],["rdbu",zd(fn,Et)],["rdgy",zd(pn,Mt)],["rdylbu",zd(dn,xt)],["rdylgn",zd(hn,Tt)],["spectral",zd(yn,Nt)],["burd",Wd(fn,Et)],["buylrd",Wd(dn,xt)],["blues",Ud(gn,Pt)],["greens",Ud(vn,Ct)],["greys",Ud(mn,Rt)],["oranges",Ud(wn,Dt)],["purples",Ud(bn,It)],["reds",Ud(Sn,At)],["turbo",Bd(Lt)],["viridis",Bd(qt)],["magma",Bd(Ft)],["inferno",Bd(_t)],["plasma",Bd(Ut)],["cividis",Bd(zt)],["cubehelix",Bd(Wt)],["warm",Bd(Bt)],["cool",Bd(Gt)],["bugn",Ud(jn,Ht)],["bupu",Ud($n,Vt)],["gnbu",Ud(On,Yt)],["orrd",Ud(kn,Jt)],["pubu",Ud(En,Xt)],["pubugn",Ud(Mn,Kt)],["purd",Ud(xn,Zt)],["rdpu",Ud(Tn,Qt)],["ylgn",Ud(Nn,nn)],["ylgnbu",Ud(Pn,tn)],["ylorbr",Ud(Cn,en)],["ylorrd",Ud(Rn,rn)],["rainbow",Gd(on)],["sinebow",Gd(an)]]);function Ud(t,n){return({length:e})=>1===e?[t[3][1]]:2===e?[t[3][1],t[3][2]]:(e=Math.max(3,Math.floor(e)))>9?St(n,e):t[e]}function zd(t,n){return({length:e})=>2===e?[t[3][0],t[3][2]]:(e=Math.max(3,Math.floor(e)))>11?St(n,e):t[e]}function Wd(t,n){return({length:e})=>2===e?[t[3][2],t[3][0]]:(e=Math.max(3,Math.floor(e)))>11?St((t=>n(1-t)),e):t[e].slice().reverse()}function Bd(t){return({length:n})=>St(t,Math.max(2,Math.floor(n)))}function Gd(t){return({length:n})=>St(t,Math.floor(n)+1).slice(0,-1)}function Hd(t){const n=`${t}`.toLowerCase();if(!_d.has(n))throw new Error(`unknown ordinal scheme: ${n}`);return _d.get(n)}function Vd(t,n){const e=Hd(t),r="function"==typeof e?e({length:n}):e;return r.length!==n?r.slice(0,n):r}const Yd=new Map([["brbg",jt],["prgn",$t],["piyg",Ot],["puor",kt],["rdbu",Et],["rdgy",Mt],["rdylbu",xt],["rdylgn",Tt],["spectral",Nt],["burd",t=>Et(1-t)],["buylrd",t=>xt(1-t)],["blues",Pt],["greens",Ct],["greys",Rt],["purples",It],["reds",At],["oranges",Dt],["turbo",Lt],["viridis",qt],["magma",Ft],["inferno",_t],["plasma",Ut],["cividis",zt],["cubehelix",Wt],["warm",Bt],["cool",Gt],["bugn",Ht],["bupu",Vt],["gnbu",Yt],["orrd",Jt],["pubugn",Kt],["pubu",Xt],["purd",Zt],["rdpu",Qt],["ylgnbu",tn],["ylgn",nn],["ylorbr",en],["ylorrd",rn],["rainbow",on],["sinebow",an]]);function Jd(t){const n=`${t}`.toLowerCase();if(!Yd.has(n))throw new Error(`unknown quantitative scheme: ${n}`);return Yd.get(n)}const Kd=new Set(["brbg","prgn","piyg","puor","rdbu","rdgy","rdylbu","rdylgn","spectral","burd","buylrd"]);function Xd(t){return null!=t&&Kd.has(`${t}`.toLowerCase())}const Zd=t=>n=>t(1-n),Qd=[0,1],th=new Map([["number",Un],["rgb",Hn],["hsl",Xn],["hcl",Zn],["lab",Qn]]);function nh(t){const n=`${t}`.toLowerCase();if(!th.has(n))throw new Error(`unknown interpolator: ${n}`);return th.get(n)}function eh(t,n,e,{type:r,nice:o,clamp:i,zero:a,domain:c=ah(t,e),unknown:u,round:s,scheme:l,interval:f,range:p=(Ed.get(t)===jd?uh(e,c):Ed.get(t)===$d?sh(e,c):Ed.get(t)===Od?Qd:void 0),interpolate:d=(Ed.get(t)===Sd?null==l&&void 0!==p?Hn:Jd(void 0!==l?l:"cyclical"===r?"rainbow":"turbo"):s?Vn:Un),reverse:h}){if(f=dd(f,r),"cyclical"!==r&&"sequential"!==r||(r="linear"),h=!!h,"function"!=typeof d&&(d=nh(d)),1===d.length?(h&&(d=Zd(d),h=!1),void 0===p&&2===(p=Float64Array.from(c,((t,n)=>n/(c.length-1)))).length&&(p=Qd),n.interpolate((p===Qd?nd:ph)(d))):n.interpolate(d),a){const[t,n]=Fn(c);(t>0||n<0)&&(c=function(t,n=Array){return t instanceof n?t.slice():n.from(t)}(c),wd(c)!==Math.sign(t)?c[c.length-1]=0:c[0]=0)}return h&&(c=zn(c)),n.domain(c).unknown(u),o&&(n.nice(function(t,n){return!0===t?void 0:"number"==typeof t?t:function(t,n){if((t=dd(t,n))&&"function"!=typeof t.ceil)throw new Error("invalid interval: missing ceil method");return t}(t,n)}(o,r)),c=n.domain()),void 0!==p&&n.range(p),i&&n.clamp(i),{type:r,domain:c,range:p,scale:n,interpolate:d,interval:f}}function rh(t,n,{exponent:e=1,...r}){return eh(t,An().exponent(e),n,{...r,type:"pow"})}function oh(t,n,{domain:e=[0],unknown:r,scheme:o="rdylbu",interpolate:i,range:a=(void 0!==i?St(i,e.length+1):Ed.get(t)===Sd?Vd(o,e.length+1):void 0),reverse:c}){const u=wd(e=ud(e));if(!isNaN(u)&&!function(t,n){for(let e=1,r=t.length,o=t[0];evoid 0===t?t:Yn(t,n))),Gn(t,(({value:t})=>void 0===t?t:Gn(t,n)))]:[0,1]}function ah(t,n){const e=Ed.get(t);return(e===jd||e===Od||e===$d?ch:ih)(n)}function ch(t){return[0,t.length?Gn(t,(({value:t})=>void 0===t?t:Gn(t,Up))):1]}function uh(t,n){const e=t.find((({radius:t})=>void 0!==t));if(void 0!==e)return[0,e.radius];const r=Jn(t,.5,(({value:t})=>void 0===t?NaN:Jn(t,.25,zp))),o=n.map((t=>3*Math.sqrt(t/r))),i=30/Gn(o);return i<1?o.map((t=>t*i)):o}function sh(t,n){const e=Kn(t,(({value:t})=>void 0===t?NaN:Kn(t,Math.abs))),r=n.map((t=>12*t/e)),o=60/Gn(r);return o<1?r.map((t=>t*o)):r}function lh(t){for(const{value:n}of t)if(void 0!==n)for(let e of n){if(e>0)return ih(t,zp);if(e<0)return ih(t,Wp)}return[1,10]}function fh(t){const n=[];for(const{value:e}of t)if(void 0!==e)for(const t of e)n.push(t);return n}function ph(t){return(n,e)=>r=>t(n+r*(e-n))}function dh(t,n,e,r,{type:o,nice:i,clamp:a,domain:c=ih(r),unknown:u,pivot:s=0,scheme:l,range:f,symmetric:p=!0,interpolate:d=(Ed.get(t)===Sd?null==l&&void 0!==f?Hn:Jd(void 0!==l?l:"rdbu"):Un),reverse:h}){s=+s;let[y,g]=c;if(P(y,g)<0&&([y,g]=[g,y],h=!h),y=Math.min(y,s),g=Math.max(g,s),"function"!=typeof d&&(d=nh(d)),void 0!==f&&(d=1===d.length?ph(d)(...f):oe(d,f)),h&&(d=Zd(d)),p){const t=e.apply(s),n=t-e.apply(y),r=e.apply(g)-t;nr&&(g=e.invert(t+n))}return n.domain([y,s,g]).unknown(u).interpolator(d),a&&n.clamp(a),i&&n.nice(i),{type:o,domain:[y,g],pivot:s,interpolate:d,scale:n}}function hh(t,n,{exponent:e=1,...r}){return dh(t,ne().exponent(e=+e),function(t){return.5===t?mh:{apply:n=>Math.sign(n)*Math.pow(Math.abs(n),t),invert:n=>Math.sign(n)*Math.pow(Math.abs(n),1/t)}}(e),n,{...r,type:"diverging-pow"})}function yh(t,n,{constant:e=1,...r}){return dh(t,re().constant(e=+e),function(t){return{apply:n=>Math.sign(n)*Math.log1p(Math.abs(n/t)),invert:n=>Math.sign(n)*Math.expm1(Math.abs(n))*t}}(e),n,r)}const gh={apply:t=>t,invert:t=>t},vh={apply:Math.log,invert:Math.exp},mh={apply:t=>Math.sign(t)*Math.sqrt(Math.abs(t)),invert:t=>Math.sign(t)*(t*t)};function wh(t,n,e,r){return eh(t,n,e,r)}const bh=Symbol("ordinal");function Sh(t,n,e,{type:r,interval:o,domain:i,range:a,reverse:c,hint:u}){return o=dd(o,r),void 0===i&&(i=Oh(e,o,t)),"categorical"!==r&&r!==bh||(r="ordinal"),c&&(i=zn(i)),n.domain(i),void 0!==a&&("function"==typeof a&&(a=a(i)),n.range(a)),{type:r,domain:i,range:a,scale:n,hint:u,interval:o}}function jh(t,n,{type:e,interval:r,domain:o,range:i,scheme:a,unknown:c,...u}){let s;if(r=dd(r,e),void 0===o&&(o=Oh(n,r,t)),Ed.get(t)===kd)s=function(t){return{fill:kh(t,"fill"),stroke:kh(t,"stroke")}}(n),i=void 0===i?function(t){return md(t.fill)?de:he}(s):sd(i,Td);else if(Ed.get(t)===Sd&&(void 0!==i||"ordinal"!==e&&e!==bh||(i=function(t,n="greys"){const e=new Set,[r,o]=Vd(n,2);for(const n of t)if(null!=n)if(!0===n)e.add(o);else{if(!1!==n)return;e.add(r)}return[...e]}(o,a),void 0!==i&&(a=void 0)),void 0===a&&void 0===i&&(a="ordinal"===e?"turbo":"tableau10"),void 0!==a))if(void 0!==i){const t=Jd(a),n=i[0],e=i[1]-i[0];i=({length:r})=>St((r=>t(n+e*r)),r)}else i=Hd(a);if(c===ce)throw new Error(`implicit unknown on ${t} scale is not supported`);return Sh(t,ue().unknown(c),n,{...u,type:e,domain:o,range:i,hint:s})}function $h(t,n,e,r){let{round:o}=e;return void 0!==o&&t.round(o=!!o),(t=Sh(r,t,n,e)).round=o,t}function Oh(t,n,e){const r=new fe;for(const{value:n,domain:e}of t){if(void 0!==e)return e();if(void 0!==n)for(const t of n)r.add(t)}if(void 0!==n){const[t,e]=Fn(r).map(n.floor,n);return n.range(t,n.offset(e))}if(r.size>1e4&&Ed.get(e)===bd)throw new Error(`implicit ordinal domain of ${e} scale has more than 10,000 values`);return pe(r,_p)}function kh(t,n){let e;for(const{hint:r}of t){const t=r?.[n];if(void 0!==t)if(void 0===e)e=t;else if(e!==t)return}return e}function Eh(t,n,e){return function(t,n=[],e={}){const r=function(t,n,{type:e,domain:r,range:o,scheme:i,pivot:a,projection:c}){if("fx"===t||"fy"===t)return"band";"x"!==t&&"y"!==t||null==c||(e=xh);for(const{type:t}of n)if(void 0!==t)if(void 0===e)e=t;else if(e!==t)throw new Error(`scale incompatible with channel: ${e} !== ${t}`);if(e===xh)return;if(void 0!==e)return e;if(void 0===r&&!n.some((({value:t})=>void 0!==t)))return;const u=Ed.get(t);if(u===jd)return"sqrt";if(u===Od||u===$d)return"linear";if(u===kd)return"ordinal";if((r||o||[]).length>2)return Th(u);if(void 0!==r)return hd(r)?Th(u):yd(r)?"utc":u!==Sd||null==a&&!Xd(i)?"linear":"diverging";const s=n.map((({value:t})=>t)).filter((t=>void 0!==t));return s.some(hd)?Th(u):s.some(yd)?"utc":u!==Sd||null==a&&!Xd(i)?"linear":"diverging"}(t,n,e);if(void 0===e.type&&void 0===e.domain&&void 0===e.range&&null==e.interval&&"fx"!==t&&"fy"!==t&&Nh({type:r})){const e=n.map((({value:t})=>t)).filter((t=>void 0!==t));e.some(yd)?Nd(`Warning: some data associated with the ${t} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${Mh(r)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${t} scale to "${Mh(r)}".`):e.some(gd)?Nd(`Warning: some data associated with the ${t} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${Mh(r)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${t} scale to "${Mh(r)}".`):e.some(vd)&&Nd(`Warning: some data associated with the ${t} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${Mh(r)}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${t} scale to "${Mh(r)}".`)}switch(e.type=r,r){case"diverging":case"diverging-sqrt":case"diverging-pow":case"diverging-log":case"diverging-symlog":case"cyclical":case"sequential":case"linear":case"sqrt":case"threshold":case"quantile":case"pow":case"log":case"symlog":e=Ph(n,e,ed);break;case"identity":switch(Ed.get(t)){case bd:e=Ph(n,e,ed);break;case kd:e=Ph(n,e,Ch)}break;case"utc":case"time":e=Ph(n,e,od)}switch(r){case"diverging":return function(t,n,e){return dh(t,te(),gh,n,e)}(t,n,e);case"diverging-sqrt":return function(t,n,e){return hh(t,n,{...e,exponent:.5})}(t,n,e);case"diverging-pow":return hh(t,n,e);case"diverging-log":return function(t,n,{base:e=10,pivot:r=1,domain:o=ih(n,r<0?Wp:zp),...i}){return dh(t,ee().base(e=+e),vh,n,{domain:o,pivot:r,...i})}(t,n,e);case"diverging-symlog":return yh(t,n,e);case"categorical":case"ordinal":case bh:return jh(t,n,e);case"cyclical":case"sequential":case"linear":return function(t,n,e){return eh(t,In(),n,e)}(t,n,e);case"sqrt":return function(t,n,e){return rh(t,n,{...e,exponent:.5})}(t,n,e);case"threshold":return oh(t,0,e);case"quantile":return function(t,n,{range:e,quantiles:r=(void 0===e?5:(e=[...e]).length),n:o=r,scheme:i="rdylbu",domain:a=fh(n),unknown:c,interpolate:u,reverse:s}){return void 0===e&&(e=void 0!==u?St(u,o):Ed.get(t)===Sd?Vd(i,o):void 0),a.length>0&&(a=qn(a,void 0===e?{length:o}:e).quantiles()),oh(t,0,{domain:a,range:e,reverse:s,unknown:c})}(t,n,e);case"quantize":return function(t,n,{range:e,n:r=(void 0===e?5:(e=[...e]).length),scheme:o="rdylbu",domain:i=ah(t,n),unknown:a,interpolate:c,reverse:u}){const[s,l]=Fn(i);let f;return void 0===e?(f=_n(s,l,r),f[0]<=s&&f.splice(0,1),f[f.length-1]>=l&&f.pop(),r=f.length+1,e=void 0!==c?St(c,r):Ed.get(t)===Sd?Vd(o,r):void 0):(f=St(Un(s,l),r+1).slice(1,-1),s instanceof Date&&(f=f.map((t=>new Date(t))))),wd(ud(i))<0&&f.reverse(),oh(t,0,{domain:f,range:e,reverse:u,unknown:a})}(t,n,e);case"pow":return rh(t,n,e);case"log":return function(t,n,{base:e=10,domain:r=lh(n),...o}){return eh(t,Dn().base(e),n,{...o,domain:r})}(t,n,e);case"symlog":return function(t,n,{constant:e=1,...r}){return eh(t,Ln().constant(e),n,r)}(t,n,e);case"utc":return function(t,n,e){return wh(t,ae(),n,e)}(t,n,e);case"time":return function(t,n,e){return wh(t,ie(),n,e)}(t,n,e);case"point":return function(t,n,{align:e=.5,padding:r=.5,...o}){return $h(se().align(e).padding(r),n,o,t)}(t,n,e);case"band":return function(t,n,{align:e=.5,padding:r=.1,paddingInner:o=r,paddingOuter:i=("fx"===t||"fy"===t?0:r),...a}){return $h(le().align(e).paddingInner(o).paddingOuter(i),n,a,t)}(t,n,e);case"identity":return Ed.get(t)===bd?{type:"identity",scale:Bn()}:{type:"identity"};case void 0:return;default:throw new Error(`unknown scale type: ${r}`)}}(t,void 0===e?void 0:[{hint:e}],{...n})}function Mh(t){return"symbol"==typeof t?t.description:t}const xh={toString:()=>"projection"};function Th(t){switch(t){case bd:return"point";case Sd:return bh;default:return"ordinal"}}function Nh({type:t}){return"ordinal"===t||"point"===t||"band"===t||t===bh}function Ph(t,{domain:n,...e},r){for(const n of t)void 0!==n.value&&(n.value=r(n.value));return{domain:void 0===n?n:r(n),...e}}function Ch(t){return sd(t,Td)}const Rh=function(t){let n,e;return(...r)=>((e?.length!==r.length||e.some(((t,n)=>t!==r[n])))&&(e=r,n=t(...r)),n)}((t=>new Intl.NumberFormat(t)));function Ih(t){return Bp(t,"Invalid Date")}function Ah(t,n){if((t=td(t))!==n)return t}!function(t="en-US"){const n=function(t="en-US"){const n=Rh(t);return t=>null==t||isNaN(t)?void 0:n.format(t)}(t)}();const Dh=/^-?([_a-z]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])([_a-z0-9-]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])*$/i;function Lh(t){if(void 0===t)return"plot-d6a7b5";if(t=`${t}`,!Dh.test(t))throw new Error(`invalid class name: ${t}`);return t}function qh(t,n){if("string"==typeof n)t.property("style",n);else if(null!=n)for(const e of t)Object.assign(e.style,n)}function Fh(t){return Nh(t)&&void 0===t.interval?void 0:"tabular-nums"}function _h(t,n){if(null==n)return n;const e=t(n);if(!e)throw new Error(`scale not found: ${n}`);return e}function Uh(t,n={},e){let{columns:r,tickFormat:o,fontVariant:i=Fh(t),swatchSize:a=15,swatchWidth:c=a,swatchHeight:u=a,marginLeft:s=0,className:l,style:f,width:p}=n;const d=qd(n);l=Lh(l),o=function(t,n){return void 0===t?yd(n)?Ih:td:"function"==typeof t?t:("string"==typeof t?yd(n)?ye:ge:nd)(t)}(o,t.domain);const h=Fd("div",d).attr("class",`${l}-swatches ${l}-swatches-${null!=r?"columns":"wrap"}`);let y;return null!=r?(y=`.${l}-swatches-columns .${l}-swatch {\n display: flex;\n align-items: center;\n break-inside: avoid;\n padding-bottom: 1px;\n}\n.${l}-swatches-columns .${l}-swatch::before {\n flex-shrink: 0;\n}\n.${l}-swatches-columns .${l}-swatch-label {\n white-space: nowrap;\n overflow: hidden;\n text-overflow: ellipsis;\n}`,h.style("columns",r).selectAll().data(t.domain).enter().append("div").attr("class",`${l}-swatch`).call(e,t,c,u).call((t=>t.append("div").attr("class",`${l}-swatch-label`).attr("title",o).text(o)))):(y=`.${l}-swatches-wrap {\n display: flex;\n align-items: center;\n min-height: 33px;\n flex-wrap: wrap;\n}\n.${l}-swatches-wrap .${l}-swatch {\n display: inline-flex;\n align-items: center;\n margin-right: 1em;\n}`,h.selectAll().data(t.domain).enter().append("span").attr("class",`${l}-swatch`).call(e,t,c,u).append((function(){return this.ownerDocument.createTextNode(o.apply(this,arguments))}))),h.call((t=>t.insert("style","*").text(`.${l}-swatches {\n font-family: system-ui, sans-serif;\n font-size: 10px;\n margin-bottom: 0.5em;\n}\n.${l}-swatch > svg {\n margin-right: 0.5em;\n overflow: visible;\n}\n${y}`))).style("margin-left",s?+s+"px":null).style("width",void 0===p?null:+p+"px").style("font-variant",Ah(i,"normal")).call(qh,f).node()}const zh=new Map([["symbol",function(t,{fill:n=(void 0!==t.hint?.fill?t.hint.fill:"none"),fillOpacity:e=1,stroke:r=(void 0!==t.hint?.stroke?t.hint.stroke:md(n)?"currentColor":"none"),strokeOpacity:o=1,strokeWidth:i=1.5,r:a=4.5,...c}={},u){const[s,l]=ad(n),[f,p]=ad(r),d=_h(u,s),h=_h(u,f),y=a*a*Math.PI;return e=cd(e)[1],o=cd(o)[1],i=cd(i)[1],Uh(t,c,((n,r,a,c)=>n.append("svg").attr("viewBox","-8 -8 16 16").attr("width",a).attr("height",c).attr("fill","color"===s?t=>d.scale(t):l).attr("fill-opacity",e).attr("stroke","color"===f?t=>h.scale(t):p).attr("stroke-opacity",o).attr("stroke-width",i).append("path").attr("d",(n=>{const e=me();return t.scale(n).draw(e,y),e}))))}],["color",Bh],["opacity",function({type:t,interpolate:n,...e},{legend:r=!0,color:o=we(0,0,0),...i}){if(!n)throw new Error(`${t} opacity scales are not supported`);!0===r&&(r="ramp");if("ramp"!==`${r}`.toLowerCase())throw new Error(`${r} opacity legends are not supported`);return Bh({type:t,...e,interpolate:Gh(o)},{legend:r,...i})}]]);function Wh({className:t,...n},{label:e,ticks:r,tickFormat:o}={},i){return function(t={},...n){let e=t;for(const r of n)for(const n in r)if(void 0===e[n]){const o=r[n];e===t?e={...e,[n]:o}:e[n]=o}return e}(i,{className:t,...n},{label:e,ticks:r,tickFormat:o})}function Bh(t,{legend:n=!0,...e}){if(!0===n&&(n="ordinal"===t.type?"swatches":"ramp"),void 0!==t.domain)switch(`${n}`.toLowerCase()){case"swatches":return function(t,{opacity:n,...e}={}){if(!Nh(t)&&!function({type:t}){return"threshold"===t}(t))throw new Error(`swatches legend requires ordinal or threshold color scale (not ${t.type})`);return Uh(t,e,((t,e,r,o)=>t.append("svg").attr("width",r).attr("height",o).attr("fill",e.scale).attr("fill-opacity",cd(n)[1]).append("rect").attr("width","100%").attr("height","100%")))}(t,e);case"ramp":return function(t,n){let{label:e=t.label,tickSize:r=6,width:o=240,height:i=44+r,marginTop:a=18,marginRight:c=0,marginBottom:u=16+r,marginLeft:s=0,style:l,ticks:f=(o-s-c)/64,tickFormat:p,fontVariant:d=Fh(t),round:h=!0,opacity:y,className:g}=n;const v=qd(n);g=Lh(g),y=cd(y)[1],null===p&&(p=()=>null);const m=Fd("svg",v).attr("class",`${g}-ramp`).attr("font-family","system-ui, sans-serif").attr("font-size",10).attr("width",o).attr("height",i).attr("viewBox",`0 0 ${o} ${i}`).call((t=>t.append("style").text(`.${g}-ramp {\n display: block;\n background: white;\n height: auto;\n height: intrinsic;\n max-width: 100%;\n overflow: visible;\n}\n.${g}-ramp text {\n white-space: pre;\n}`))).call(qh,l);let w,b=t=>t.selectAll(".tick line").attr("y1",a+u-i);const S=h?(t,n)=>t.rangeRound(n):(t,n)=>t.range(n),{type:j,domain:$,range:O,interpolate:k,scale:E,pivot:M}=t;if(k){const t=void 0===O?k:oe(1===k.length?ph(k):k,O);w=S(E.copy(),St(Un(s,o-c),Math.min($.length+(void 0!==M),void 0===O?1/0:O.length)));const n=256,e=v.document.createElement("canvas");e.width=n,e.height=1;const r=e.getContext("2d");for(let e=0,o=n-1;et:"string"==typeof p?ge(p):p;w=S(In().domain([-1,O.length-1]),[s,o-c]),m.append("g").attr("fill-opacity",y).selectAll().data(O).enter().append("rect").attr("x",((t,n)=>w(n-1))).attr("y",a).attr("width",((t,n)=>w(n)-w(n-1))).attr("height",i-a-u).attr("fill",(t=>t)),f=sd(t,((t,n)=>n)),p=e=>n(t[e],e)}else w=S(le().domain($),[s,o-c]),m.append("g").attr("fill-opacity",y).selectAll().data($).enter().append("rect").attr("x",w).attr("y",a).attr("width",Math.max(0,w.bandwidth()-1)).attr("height",i-a-u).attr("fill",E),b=()=>{};return m.append("g").attr("transform",`translate(0,${i-u})`).call(ve(w).ticks(Array.isArray(f)?null:f,"string"==typeof p?p:void 0).tickFormat("function"==typeof p?p:void 0).tickSize(r).tickValues(Array.isArray(f)?f:null)).attr("font-size",null).attr("font-family",null).attr("font-variant",Ah(d,"normal")).call(b).call((t=>t.select(".domain").remove())),void 0!==e&&m.append("text").attr("x",s).attr("y",a-6).attr("fill","currentColor").attr("font-weight","bold").text(e),m.node()}(t,e);default:throw new Error(`unknown legend type: ${n}`)}}function Gh(t){const{r:n,g:e,b:r}=we(t)||we(0,0,0);return t=>`rgba(${n},${e},${r},${t})`}var Hh="#ch-plugin-legend",Vh={enabled:!0,itemSelector:null,label:null,width:130},Yh=function(){function n(t){!function(t,n){if(!(t instanceof n))throw new TypeError("Cannot call a class as a function")}(this,n),this.name="Legend",this.calendar=t,this.root=null,this.shown=!1,this.options=Vh}var e,r,o;return e=n,r=[{key:"setup",value:function(t){this.options=Object.assign(Object.assign({},Vh),t)}},{key:"paint",value:function(){var n=this.calendar.options.options.scale,e=this.options,r=e.enabled,o=e.itemSelector;if(!r||o&&t(o).empty())return this.destroy();this.shown=!0,this.root=t(o||this.calendar.options.options.itemSelector),this.root.select(Hh).empty()?this.root=this.root.append("div").attr("id",Hh.slice(1)):this.root=this.root.select(Hh);var i=function(t={}){for(const[n,e]of zh){const r=t[n];if(fd(r)){const o=qd(t);let i;if("symbol"===n){const{fill:n,stroke:e=(void 0===n&&fd(t.color)?"color":void 0)}=t;i={fill:n,stroke:e}}return e(Eh(n,r,i),Wh(o,r,t),(n=>fd(t[n])?Eh(n,t[n]):null))}}throw new Error("unknown legend type; no scale found")}(Object.assign(Object.assign({},n),this.options));return this.root.selectAll("*").remove(),this.root.append((function(){return i})),Promise.resolve()}},{key:"destroy",value:function(){return null!==this.root&&(this.root.remove(),this.root=null),Promise.resolve()}}],r&&be(e.prototype,r),o&&be(e,o),Object.defineProperty(e,"prototype",{writable:!1}),n}();export{Yh as default};//# sourceMappingURL=Legend.min.esm.js.map diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.esm.js.map b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.esm.js.map new file mode 100644 index 0000000..26452c3 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.esm.js.map @@ -0,0 +1 @@ +{"version":3,"file":"Legend.min.esm.js","sources":["../../node_modules/core-js/internals/fails.js","../../node_modules/core-js/internals/descriptors.js","../../node_modules/core-js/internals/function-bind-native.js","../../node_modules/core-js/internals/function-uncurry-this.js","../../node_modules/core-js/internals/is-null-or-undefined.js","../../node_modules/core-js/internals/require-object-coercible.js","../../node_modules/core-js/internals/to-object.js","../../node_modules/core-js/internals/has-own-property.js","../../node_modules/core-js/internals/function-name.js","../../node_modules/core-js/internals/document-all.js","../../node_modules/core-js/internals/is-callable.js","../../node_modules/core-js/internals/global.js","../../node_modules/core-js/internals/define-global-property.js","../../node_modules/core-js/internals/shared-store.js","../../node_modules/core-js/internals/inspect-source.js","../../node_modules/core-js/internals/engine-v8-version.js","../../node_modules/core-js/internals/weak-map-basic-detection.js","../../node_modules/core-js/internals/is-object.js","../../node_modules/core-js/internals/document-create-element.js","../../node_modules/core-js/internals/ie8-dom-define.js","../../node_modules/core-js/internals/v8-prototype-define-bug.js","../../node_modules/core-js/internals/an-object.js","../../node_modules/core-js/internals/function-call.js","../../node_modules/core-js/internals/get-built-in.js","../../node_modules/core-js/internals/object-is-prototype-of.js","../../node_modules/core-js/internals/engine-user-agent.js","../../node_modules/core-js/internals/symbol-constructor-detection.js","../../node_modules/core-js/internals/use-symbol-as-uid.js","../../node_modules/core-js/internals/is-symbol.js","../../node_modules/core-js/internals/try-to-string.js","../../node_modules/core-js/internals/a-callable.js","../../node_modules/core-js/internals/get-method.js","../../node_modules/core-js/internals/ordinary-to-primitive.js","../../node_modules/core-js/internals/shared.js","../../node_modules/core-js/internals/uid.js","../../node_modules/core-js/internals/well-known-symbol.js","../../node_modules/core-js/internals/to-primitive.js","../../node_modules/core-js/internals/to-property-key.js","../../node_modules/core-js/internals/object-define-property.js","../../node_modules/core-js/internals/create-property-descriptor.js","../../node_modules/core-js/internals/internal-state.js","../../node_modules/core-js/internals/create-non-enumerable-property.js","../../node_modules/core-js/internals/shared-key.js","../../node_modules/core-js/internals/hidden-keys.js","../../node_modules/core-js/internals/make-built-in.js","../../node_modules/core-js/internals/define-built-in-accessor.js","../../node_modules/core-js/modules/es.function.name.js","../../node_modules/core-js/internals/object-property-is-enumerable.js","../../node_modules/core-js/internals/classof-raw.js","../../node_modules/core-js/internals/indexed-object.js","../../node_modules/core-js/internals/to-indexed-object.js","../../node_modules/core-js/internals/object-get-own-property-descriptor.js","../../node_modules/core-js/internals/define-built-in.js","../../node_modules/core-js/internals/math-trunc.js","../../node_modules/core-js/internals/to-integer-or-infinity.js","../../node_modules/core-js/internals/to-absolute-index.js","../../node_modules/core-js/internals/to-length.js","../../node_modules/core-js/internals/length-of-array-like.js","../../node_modules/core-js/internals/array-includes.js","../../node_modules/core-js/internals/object-keys-internal.js","../../node_modules/core-js/internals/enum-bug-keys.js","../../node_modules/core-js/internals/object-get-own-property-names.js","../../node_modules/core-js/internals/object-get-own-property-symbols.js","../../node_modules/core-js/internals/own-keys.js","../../node_modules/core-js/internals/copy-constructor-properties.js","../../node_modules/core-js/internals/is-forced.js","../../node_modules/core-js/internals/export.js","../../node_modules/core-js/internals/object-keys.js","../../node_modules/core-js/internals/object-assign.js","../../node_modules/core-js/modules/es.object.assign.js","../../node_modules/core-js/internals/to-string-tag-support.js","../../node_modules/core-js/internals/classof.js","../../node_modules/core-js/internals/object-to-string.js","../../node_modules/core-js/modules/es.object.to-string.js","../../node_modules/core-js/internals/engine-is-node.js","../../node_modules/core-js/internals/function-uncurry-this-accessor.js","../../node_modules/core-js/internals/a-possible-prototype.js","../../node_modules/core-js/internals/object-set-prototype-of.js","../../node_modules/core-js/internals/set-to-string-tag.js","../../node_modules/core-js/internals/set-species.js","../../node_modules/core-js/internals/an-instance.js","../../node_modules/core-js/internals/is-constructor.js","../../node_modules/core-js/internals/task.js","../../node_modules/core-js/internals/a-constructor.js","../../node_modules/core-js/internals/species-constructor.js","../../node_modules/core-js/internals/function-apply.js","../../node_modules/core-js/internals/function-uncurry-this-clause.js","../../node_modules/core-js/internals/function-bind-context.js","../../node_modules/core-js/internals/html.js","../../node_modules/core-js/internals/array-slice.js","../../node_modules/core-js/internals/validate-arguments-length.js","../../node_modules/core-js/internals/engine-is-ios.js","../../node_modules/core-js/internals/queue.js","../../node_modules/core-js/internals/microtask.js","../../node_modules/core-js/internals/engine-is-ios-pebble.js","../../node_modules/core-js/internals/engine-is-webos-webkit.js","../../node_modules/core-js/internals/perform.js","../../node_modules/core-js/internals/promise-native-constructor.js","../../node_modules/core-js/internals/engine-is-deno.js","../../node_modules/core-js/internals/engine-is-browser.js","../../node_modules/core-js/internals/promise-constructor-detection.js","../../node_modules/core-js/internals/new-promise-capability.js","../../node_modules/core-js/modules/es.promise.constructor.js","../../node_modules/core-js/internals/host-report-errors.js","../../node_modules/core-js/internals/iterators.js","../../node_modules/core-js/internals/is-array-iterator-method.js","../../node_modules/core-js/internals/get-iterator-method.js","../../node_modules/core-js/internals/get-iterator.js","../../node_modules/core-js/internals/iterator-close.js","../../node_modules/core-js/internals/iterate.js","../../node_modules/core-js/internals/check-correctness-of-iteration.js","../../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","../../node_modules/core-js/modules/es.promise.all.js","../../node_modules/core-js/modules/es.promise.catch.js","../../node_modules/core-js/modules/es.promise.race.js","../../node_modules/core-js/modules/es.promise.reject.js","../../node_modules/core-js/internals/promise-resolve.js","../../node_modules/core-js/modules/es.promise.resolve.js","../../node_modules/@observablehq/plot/src/defined.js","../../node_modules/isoformat/src/format.js","../../node_modules/isoformat/src/parse.js","../../node_modules/@observablehq/plot/src/time.js","../../node_modules/@observablehq/plot/src/options.js","../../node_modules/@observablehq/plot/src/scales/index.js","../../node_modules/@observablehq/plot/src/symbol.js","../../node_modules/@observablehq/plot/src/warnings.js","../../node_modules/@observablehq/plot/src/projection.js","../../node_modules/@observablehq/plot/src/context.js","../../node_modules/@observablehq/plot/src/scales/schemes.js","../../node_modules/@observablehq/plot/src/scales/quantitative.js","../../node_modules/@observablehq/plot/src/scales/diverging.js","../../node_modules/@observablehq/plot/src/scales/temporal.js","../../node_modules/@observablehq/plot/src/scales/ordinal.js","../../node_modules/@observablehq/plot/src/scales.js","../../node_modules/@observablehq/plot/src/format.js","../../node_modules/@observablehq/plot/src/memoize.js","../../node_modules/@observablehq/plot/src/style.js","../../node_modules/@observablehq/plot/src/axes.js","../../node_modules/@observablehq/plot/src/legends/swatches.js","../../node_modules/@observablehq/plot/src/legends.js","../../node_modules/@observablehq/plot/src/legends/ramp.js","../../../src/plugins/Legend.ts"],"sourcesContent":["'use strict';\nmodule.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-function-prototype-bind -- safe\n var test = (function () { /* empty */ }).bind();\n // eslint-disable-next-line no-prototype-builtins -- safe\n return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n return function () {\n return call.apply(fn, arguments);\n };\n};\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n return it === null || it === undefined;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n return it;\n};\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar documentAll = typeof document == 'object' && document.all;\n\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nvar IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;\n\nmodule.exports = {\n all: documentAll,\n IS_HTMLDDA: IS_HTMLDDA\n};\n","'use strict';\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = $documentAll.IS_HTMLDDA ? function (argument) {\n return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n return typeof argument == 'function';\n};\n","'use strict';\nvar check = function (it) {\n return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n check(typeof this == 'object' && this) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\nmodule.exports = $documentAll.IS_HTMLDDA ? function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;\n} : function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a !== 7;\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype !== 42;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol('symbol detection');\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n // of course, fail.\n return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n try {\n return $String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.34.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',\n license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',\n source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name)) {\n WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n ? Symbol[name]\n : createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw new $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","'use strict';\nmodule.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n /* eslint-disable no-self-assign -- prototype methods protection */\n store.get = store.get;\n store.has = store.has;\n store.set = store.set;\n /* eslint-enable no-self-assign -- prototype methods protection */\n set = function (it, metadata) {\n if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n store.set(it, metadata);\n return metadata;\n };\n get = function (it) {\n return store.get(it) || {};\n };\n has = function (it) {\n return store.has(it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (options && options.getter) name = 'get ' + name;\n if (options && options.setter) name = 'set ' + name;\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n else value.name = name;\n }\n if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n defineProperty(value, 'length', { value: options.arity });\n }\n try {\n if (options && hasOwn(options, 'constructor') && options.constructor) {\n if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n } else if (value.prototype) value.prototype = undefined;\n } catch (error) { /* empty */ }\n var state = enforceInternalState(value);\n if (!hasOwn(state, 'source')) {\n state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineProperty = require('../internals/object-define-property');\n\nmodule.exports = function (target, name, descriptor) {\n if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });\n if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });\n return defineProperty.f(target, name, descriptor);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar FUNCTION_NAME_EXISTS = require('../internals/function-name').EXISTS;\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\n\nvar FunctionPrototype = Function.prototype;\nvar functionToString = uncurryThis(FunctionPrototype.toString);\nvar nameRE = /function\\b(?:\\s|\\/\\*[\\S\\s]*?\\*\\/|\\/\\/[^\\n\\r]*[\\n\\r]+)*([^\\s(/]*)/;\nvar regExpExec = uncurryThis(nameRE.exec);\nvar NAME = 'name';\n\n// Function instances `.name` property\n// https://tc39.es/ecma262/#sec-function-instances-name\nif (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {\n defineBuiltInAccessor(FunctionPrototype, NAME, {\n configurable: true,\n get: function () {\n try {\n return regExpExec(nameRE, functionToString(this))[1];\n } catch (error) {\n return '';\n }\n }\n });\n}\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- NaN check\n return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el !== el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value !== value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value === POLYFILL ? true\n : value === NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.dontCallGetSet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || defineGlobalProperty(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.dontCallGetSet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n defineBuiltIn(target, key, sourceProperty, options);\n }\n};\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol('assign detection');\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","'use strict';\nvar $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {\n assign: assign\n});\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar global = require('../internals/global');\nvar classof = require('../internals/classof-raw');\n\nmodule.exports = classof(global.process) === 'process';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nmodule.exports = function (object, key, method) {\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));\n } catch (error) { /* empty */ }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw new $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","'use strict';\n/* eslint-disable no-proto -- safe */\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (target, TAG, STATIC) {\n if (target && !STATIC) target = target.prototype;\n if (target && !hasOwn(target, TO_STRING_TAG)) {\n defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineBuiltInAccessor(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw new $TypeError('Incorrect invocation');\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.test(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n }\n try {\n // we can't check .prototype since constructors produced by .bind haven't it\n // `Function#toString` throws on some built-it function in some legacy engines\n // (for example, `DOMQuad` and similar in FF41-)\n return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n } catch (error) {\n return true;\n }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar $location, defer, channel, port;\n\nfails(function () {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n $location = global.location;\n});\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar eventListener = function (event) {\n run(event.data);\n};\n\nvar globalPostMessageDefer = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), $location.protocol + '//' + $location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(handler) {\n validateArgumentsLength(arguments.length, 1);\n var fn = isCallable(handler) ? handler : Function(handler);\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(fn, undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = eventListener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n $location && $location.protocol !== 'file:' &&\n !fails(globalPostMessageDefer)\n ) {\n defer = globalPostMessageDefer;\n global.addEventListener('message', eventListener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","'use strict';\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a constructor');\n};\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","'use strict';\nvar classofRaw = require('../internals/classof-raw');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (fn) {\n // Nashorn bug:\n // https://github.com/zloirock/core-js/issues/1128\n // https://github.com/zloirock/core-js/issues/1130\n if (classofRaw(fn) === 'Function') return uncurryThis(fn);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","'use strict';\nvar $TypeError = TypeError;\n\nmodule.exports = function (passed, required) {\n if (passed < required) throw new $TypeError('Not enough arguments');\n return passed;\n};\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line redos/no-vulnerable -- safe\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","'use strict';\nvar Queue = function () {\n this.head = null;\n this.tail = null;\n};\n\nQueue.prototype = {\n add: function (item) {\n var entry = { item: item, next: null };\n var tail = this.tail;\n if (tail) tail.next = entry;\n else this.head = entry;\n this.tail = entry;\n },\n get: function () {\n var entry = this.head;\n if (entry) {\n var next = this.head = entry.next;\n if (next === null) this.tail = null;\n return entry.item;\n }\n }\n};\n\nmodule.exports = Queue;\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar Queue = require('../internals/queue');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar microtask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\nvar notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!microtask) {\n var queue = new Queue();\n\n var flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (fn = queue.get()) try {\n fn();\n } catch (error) {\n if (queue.head) notify();\n throw error;\n }\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessage\n // - onreadystatechange\n // - setTimeout\n } else {\n // `webpack` dev server bug on IE global methods - use bind(fn, global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n\n microtask = function (fn) {\n if (!queue.head) notify();\n queue.add(fn);\n };\n}\n\nmodule.exports = microtask;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","'use strict';\nvar global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n && typeof window == 'object'\n && typeof document == 'object';\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n // Detect correctness of subclassing with @@species support\n var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar $TypeError = TypeError;\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar IS_NODE = require('../internals/engine-is-node');\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar perform = require('../internals/perform');\nvar Queue = require('../internals/queue');\nvar InternalStateModule = require('../internals/internal-state');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar PromiseConstructorDetection = require('../internals/promise-constructor-detection');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\n\nvar PROMISE = 'Promise';\nvar FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;\nvar NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;\nvar NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar PromiseConstructor = NativePromiseConstructor;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar callReaction = function (reaction, state) {\n var value = state.value;\n var ok = state.state === FULFILLED;\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(new TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n microtask(function () {\n var reactions = state.reactions;\n var reaction;\n while (reaction = reactions.get()) {\n callReaction(reaction, state);\n }\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw new TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED_PROMISE_CONSTRUCTOR) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalPromiseState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n\n PromisePrototype = PromiseConstructor.prototype;\n\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: new Queue(),\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n state.parent = true;\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n if (state.state === PENDING) state.reactions.add(reaction);\n else microtask(function () {\n callReaction(reaction, state);\n });\n return reaction.promise;\n });\n\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalPromiseState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!NATIVE_PROMISE_SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n","'use strict';\nmodule.exports = function (a, b) {\n try {\n // eslint-disable-next-line no-console -- safe\n arguments.length === 1 ? console.error(a) : console.error(a, b);\n } catch (error) { /* empty */ }\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw new $TypeError(tryToString(argument) + ' is not iterable');\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_RECORD = !!(options && options.IS_RECORD);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_RECORD) {\n iterator = iterable.iterator;\n } else if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = IS_RECORD ? iterable.next : iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n try {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n } catch (error) { return false; } // workaround of old WebKit + `eval` bug\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.all` method\n// https://tc39.es/ecma262/#sec-promise.all\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar defineBuiltIn = require('../internals/define-built-in');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\n\n// `Promise.prototype.catch` method\n// https://tc39.es/ecma262/#sec-promise.prototype.catch\n$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n});\n\n// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromiseConstructor)) {\n var method = getBuiltIn('Promise').prototype['catch'];\n if (NativePromisePrototype['catch'] !== method) {\n defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.race` method\n// https://tc39.es/ecma262/#sec-promise.race\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\n// `Promise.reject` method\n// https://tc39.es/ecma262/#sec-promise.reject\n$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n reject: function reject(r) {\n var capability = newPromiseCapabilityModule.f(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar promiseResolve = require('../internals/promise-resolve');\n\nvar PromiseConstructorWrapper = getBuiltIn('Promise');\nvar CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;\n\n// `Promise.resolve` method\n// https://tc39.es/ecma262/#sec-promise.resolve\n$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {\n resolve: function resolve(x) {\n return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);\n }\n});\n","import {ascending, descending} from \"d3\";\n\nexport function defined(x) {\n return x != null && !Number.isNaN(x);\n}\n\nexport function ascendingDefined(a, b) {\n return +defined(b) - +defined(a) || ascending(a, b);\n}\n\nexport function descendingDefined(a, b) {\n return +defined(b) - +defined(a) || descending(a, b);\n}\n\nexport function nonempty(x) {\n return x != null && `${x}` !== \"\";\n}\n\nexport function finite(x) {\n return isFinite(x) ? x : NaN;\n}\n\nexport function positive(x) {\n return x > 0 && isFinite(x) ? x : NaN;\n}\n\nexport function negative(x) {\n return x < 0 && isFinite(x) ? x : NaN;\n}\n","export default function format(date, fallback) {\n if (!(date instanceof Date)) date = new Date(+date);\n if (isNaN(date)) return typeof fallback === \"function\" ? fallback(date) : fallback;\n const hours = date.getUTCHours();\n const minutes = date.getUTCMinutes();\n const seconds = date.getUTCSeconds();\n const milliseconds = date.getUTCMilliseconds();\n return `${formatYear(date.getUTCFullYear(), 4)}-${pad(date.getUTCMonth() + 1, 2)}-${pad(date.getUTCDate(), 2)}${\n hours || minutes || seconds || milliseconds ? `T${pad(hours, 2)}:${pad(minutes, 2)}${\n seconds || milliseconds ? `:${pad(seconds, 2)}${\n milliseconds ? `.${pad(milliseconds, 3)}` : ``\n }` : ``\n }Z` : ``\n }`;\n}\n\nfunction formatYear(year) {\n return year < 0 ? `-${pad(-year, 6)}`\n : year > 9999 ? `+${pad(year, 6)}`\n : pad(year, 4);\n}\n\nfunction pad(value, width) {\n return `${value}`.padStart(width, \"0\");\n}\n","const re = /^(?:[-+]\\d{2})?\\d{4}(?:-\\d{2}(?:-\\d{2})?)?(?:T\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{3})?)?(?:Z|[-+]\\d{2}:?\\d{2})?)?$/;\n\nexport default function parse(string, fallback) {\n if (!re.test(string += \"\")) return typeof fallback === \"function\" ? fallback(string) : fallback;\n return new Date(string);\n}\n","import {utcSecond, utcMinute, utcHour, utcDay, utcWeek, utcMonth, utcYear} from \"d3\";\nimport {utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSunday} from \"d3\";\nimport {timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear} from \"d3\";\nimport {timeMonday, timeTuesday, timeWednesday, timeThursday, timeFriday, timeSaturday, timeSunday} from \"d3\";\n\nconst timeIntervals = new Map([\n [\"second\", timeSecond],\n [\"minute\", timeMinute],\n [\"hour\", timeHour],\n [\"day\", timeDay],\n [\"week\", timeWeek],\n [\"month\", timeMonth],\n [\"quarter\", timeMonth.every(3)],\n [\"half\", timeMonth.every(6)],\n [\"year\", timeYear],\n [\"monday\", timeMonday],\n [\"tuesday\", timeTuesday],\n [\"wednesday\", timeWednesday],\n [\"thursday\", timeThursday],\n [\"friday\", timeFriday],\n [\"saturday\", timeSaturday],\n [\"sunday\", timeSunday]\n]);\n\nconst utcIntervals = new Map([\n [\"second\", utcSecond],\n [\"minute\", utcMinute],\n [\"hour\", utcHour],\n [\"day\", utcDay],\n [\"week\", utcWeek],\n [\"month\", utcMonth],\n [\"quarter\", utcMonth.every(3)],\n [\"half\", utcMonth.every(6)],\n [\"year\", utcYear],\n [\"monday\", utcMonday],\n [\"tuesday\", utcTuesday],\n [\"wednesday\", utcWednesday],\n [\"thursday\", utcThursday],\n [\"friday\", utcFriday],\n [\"saturday\", utcSaturday],\n [\"sunday\", utcSunday]\n]);\n\nexport function maybeTimeInterval(interval) {\n const i = timeIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n\nexport function maybeUtcInterval(interval) {\n const i = utcIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n","import {parse as isoParse} from \"isoformat\";\nimport {color, descending, range as rangei, quantile} from \"d3\";\nimport {maybeTimeInterval, maybeUtcInterval} from \"./time.js\";\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\nexport const TypedArray = Object.getPrototypeOf(Uint8Array);\nconst objectToString = Object.prototype.toString;\n\nexport function valueof(data, value, type) {\n const valueType = typeof value;\n return valueType === \"string\"\n ? maybeTypedMap(data, field(value), type)\n : valueType === \"function\"\n ? maybeTypedMap(data, value, type)\n : valueType === \"number\" || value instanceof Date || valueType === \"boolean\"\n ? map(data, constant(value), type)\n : typeof value?.transform === \"function\"\n ? maybeTypedArrayify(value.transform(data), type)\n : maybeTypedArrayify(value, type);\n}\n\nfunction maybeTypedMap(data, f, type) {\n return map(data, type?.prototype instanceof TypedArray ? floater(f) : f, type);\n}\n\nfunction maybeTypedArrayify(data, type) {\n return type === undefined\n ? arrayify(data) // preserve undefined type\n : data instanceof type\n ? data\n : type.prototype instanceof TypedArray && !(data instanceof TypedArray)\n ? type.from(data, coerceNumber)\n : type.from(data);\n}\n\nfunction floater(f) {\n return (d, i) => coerceNumber(f(d, i));\n}\n\nexport const field = (name) => (d) => d[name];\nexport const indexOf = {transform: range};\nexport const identity = {transform: (d) => d};\nexport const zero = () => 0;\nexport const one = () => 1;\nexport const yes = () => true;\nexport const string = (x) => (x == null ? x : `${x}`);\nexport const number = (x) => (x == null ? x : +x);\nexport const boolean = (x) => (x == null ? x : !!x);\nexport const first = (x) => (x ? x[0] : undefined);\nexport const second = (x) => (x ? x[1] : undefined);\nexport const third = (x) => (x ? x[2] : undefined);\nexport const constant = (x) => () => x;\n\n// Converts a string like “p25” into a function that takes an index I and an\n// accessor function f, returning the corresponding percentile value.\nexport function percentile(reduce) {\n const p = +`${reduce}`.slice(1) / 100;\n return (I, f) => quantile(I, p, f);\n}\n\n// If the values are specified as a typed array, no coercion is required.\nexport function coerceNumbers(values) {\n return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array);\n}\n\n// Unlike Mark’s number, here we want to convert null and undefined to NaN since\n// the result will be stored in a Float64Array and we don’t want null to be\n// coerced to zero. We use Number instead of unary + to allow BigInt coercion.\nfunction coerceNumber(x) {\n return x == null ? NaN : Number(x);\n}\n\nexport function coerceDates(values) {\n return map(values, coerceDate);\n}\n\n// When coercing strings to dates, we only want to allow the ISO 8601 format\n// since the built-in string parsing of the Date constructor varies across\n// browsers. (In the future, this could be made more liberal if desired, though\n// it is still generally preferable to do date parsing yourself explicitly,\n// rather than rely on Plot.) Any non-string values are coerced to number first\n// and treated as milliseconds since UNIX epoch.\nexport function coerceDate(x) {\n return x instanceof Date && !isNaN(x)\n ? x\n : typeof x === \"string\"\n ? isoParse(x)\n : x == null || isNaN((x = +x))\n ? undefined\n : new Date(x);\n}\n\n// Some channels may allow a string constant to be specified; to differentiate\n// string constants (e.g., \"red\") from named fields (e.g., \"date\"), this\n// function tests whether the given value is a CSS color string and returns a\n// tuple [channel, constant] where one of the two is undefined, and the other is\n// the given value. If you wish to reference a named field that is also a valid\n// CSS color, use an accessor (d => d.red) instead.\nexport function maybeColorChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null ? [undefined, \"none\"] : isColor(value) ? [undefined, value] : [value, undefined];\n}\n\n// Similar to maybeColorChannel, this tests whether the given value is a number\n// indicating a constant, and otherwise assumes that it’s a channel value.\nexport function maybeNumberChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null || typeof value === \"number\" ? [undefined, value] : [value, undefined];\n}\n\n// Validates the specified optional string against the allowed list of keywords.\nexport function maybeKeyword(input, name, allowed) {\n if (input != null) return keyword(input, name, allowed);\n}\n\n// Validates the specified required string against the allowed list of keywords.\nexport function keyword(input, name, allowed) {\n const i = `${input}`.toLowerCase();\n if (!allowed.includes(i)) throw new Error(`invalid ${name}: ${input}`);\n return i;\n}\n\n// Promotes the specified data to an array as needed.\nexport function arrayify(data) {\n return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data);\n}\n\n// An optimization of type.from(values, f): if the given values are already an\n// instanceof the desired array type, the faster values.map method is used.\nexport function map(values, f, type = Array) {\n return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f);\n}\n\n// An optimization of type.from(values): if the given values are already an\n// instanceof the desired array type, the faster values.slice method is used.\nexport function slice(values, type = Array) {\n return values instanceof type ? values.slice() : type.from(values);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a primitive value.\nexport function isObject(option) {\n return option?.toString === objectToString;\n}\n\n// Disambiguates a scale options object (e.g., {color: {type: \"linear\"}}) from\n// some other option (e.g., {color: \"red\"}). When creating standalone legends,\n// this is used to test whether a scale is defined; this should be consistent\n// with inferScaleType when there are no channels associated with the scale, and\n// if this returns true, then normalizeScale must return non-null.\nexport function isScaleOptions(option) {\n return isObject(option) && (option.type !== undefined || option.domain !== undefined);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a channel value\n// definition expressed as a channel transform (e.g., {transform: …}).\nexport function isOptions(option) {\n return isObject(option) && typeof option.transform !== \"function\";\n}\n\n// Disambiguates a sort transform (e.g., {sort: \"date\"}) from a channel domain\n// sort definition (e.g., {sort: {y: \"x\"}}).\nexport function isDomainSort(sort) {\n return isOptions(sort) && sort.value === undefined && sort.channel === undefined;\n}\n\n// For marks specified either as [0, x] or [x1, x2], such as areas and bars.\nexport function maybeZero(x, x1, x2, x3 = identity) {\n if (x1 === undefined && x2 === undefined) {\n // {x} or {}\n (x1 = 0), (x2 = x === undefined ? x3 : x);\n } else if (x1 === undefined) {\n // {x, x2} or {x2}\n x1 = x === undefined ? 0 : x;\n } else if (x2 === undefined) {\n // {x, x1} or {x1}\n x2 = x === undefined ? 0 : x;\n }\n return [x1, x2];\n}\n\n// For marks that have x and y channels (e.g., cell, dot, line, text).\nexport function maybeTuple(x, y) {\n return x === undefined && y === undefined ? [first, second] : [x, y];\n}\n\n// A helper for extracting the z channel, if it is variable. Used by transforms\n// that require series, such as moving average and normalize.\nexport function maybeZ({z, fill, stroke} = {}) {\n if (z === undefined) [z] = maybeColorChannel(fill);\n if (z === undefined) [z] = maybeColorChannel(stroke);\n return z;\n}\n\n// Returns a Uint32Array with elements [0, 1, 2, … data.length - 1].\nexport function range(data) {\n const n = data.length;\n const r = new Uint32Array(n);\n for (let i = 0; i < n; ++i) r[i] = i;\n return r;\n}\n\n// Returns a filtered range of data given the test function.\nexport function where(data, test) {\n return range(data).filter((i) => test(data[i], i, data));\n}\n\n// Returns an array [values[index[0]], values[index[1]], …].\nexport function take(values, index) {\n return map(index, (i) => values[i]);\n}\n\n// Based on InternMap (d3.group).\nexport function keyof(value) {\n return value !== null && typeof value === \"object\" ? value.valueOf() : value;\n}\n\nexport function maybeInput(key, options) {\n if (options[key] !== undefined) return options[key];\n switch (key) {\n case \"x1\":\n case \"x2\":\n key = \"x\";\n break;\n case \"y1\":\n case \"y2\":\n key = \"y\";\n break;\n }\n return options[key];\n}\n\nexport function column(source) {\n // Defines a column whose values are lazily populated by calling the returned\n // setter. If the given source is labeled, the label is propagated to the\n // returned column definition.\n let value;\n return [\n {\n transform: () => value,\n label: labelof(source)\n },\n (v) => (value = v)\n ];\n}\n\n// Like column, but allows the source to be null.\nexport function maybeColumn(source) {\n return source == null ? [source] : column(source);\n}\n\nexport function labelof(value, defaultValue) {\n return typeof value === \"string\" ? value : value && value.label !== undefined ? value.label : defaultValue;\n}\n\n// Assuming that both x1 and x2 and lazy columns (per above), this derives a new\n// a column that’s the average of the two, and which inherits the column label\n// (if any). Both input columns are assumed to be quantitative. If either column\n// is temporal, the returned column is also temporal.\nexport function mid(x1, x2) {\n return {\n transform(data) {\n const X1 = x1.transform(data);\n const X2 = x2.transform(data);\n return isTemporal(X1) || isTemporal(X2)\n ? map(X1, (_, i) => new Date((+X1[i] + +X2[i]) / 2))\n : map(X1, (_, i) => (+X1[i] + +X2[i]) / 2, Float64Array);\n },\n label: x1.label\n };\n}\n\n// If interval is not nullish, converts interval shorthand such as a number (for\n// multiples) or a time interval name (such as “day”) to a {floor, offset,\n// range} object similar to a D3 time interval.\nexport function maybeInterval(interval, type) {\n if (interval == null) return;\n if (typeof interval === \"number\") {\n if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval;\n const n = Math.abs(interval);\n return interval < 0\n ? {\n floor: (d) => Math.floor(d * n) / n,\n offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo * n), hi * n).map((x) => x / n)\n }\n : {\n floor: (d) => Math.floor(d / n) * n,\n offset: (d) => d + n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo / n), hi / n).map((x) => x * n)\n };\n }\n if (typeof interval === \"string\") return (type === \"time\" ? maybeTimeInterval : maybeUtcInterval)(interval);\n if (typeof interval.floor !== \"function\") throw new Error(\"invalid interval; missing floor method\");\n if (typeof interval.offset !== \"function\") throw new Error(\"invalid interval; missing offset method\");\n return interval;\n}\n\n// Like maybeInterval, but requires a range method too.\nexport function maybeRangeInterval(interval, type) {\n interval = maybeInterval(interval, type);\n if (interval && typeof interval.range !== \"function\") throw new Error(\"invalid interval: missing range method\");\n return interval;\n}\n\n// Like maybeRangeInterval, but requires a ceil method too.\nexport function maybeNiceInterval(interval, type) {\n interval = maybeRangeInterval(interval, type);\n if (interval && typeof interval.ceil !== \"function\") throw new Error(\"invalid interval: missing ceil method\");\n return interval;\n}\n\n// This distinguishes between per-dimension options and a standalone value.\nexport function maybeValue(value) {\n return value === undefined || isOptions(value) ? value : {value};\n}\n\n// Coerces the given channel values (if any) to numbers. This is useful when\n// values will be interpolated into other code, such as an SVG transform, and\n// where we don’t wish to allow unexpected behavior for weird input.\nexport function numberChannel(source) {\n return source == null\n ? null\n : {\n transform: (data) => valueof(data, source, Float64Array),\n label: labelof(source)\n };\n}\n\nexport function isTuples(data) {\n if (!isIterable(data)) return false;\n for (const d of data) {\n if (d == null) continue;\n return typeof d === \"object\" && \"0\" in d && \"1\" in d;\n }\n}\n\nexport function isIterable(value) {\n return value && typeof value[Symbol.iterator] === \"function\";\n}\n\nexport function isTextual(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value !== \"object\" || value instanceof Date;\n }\n}\n\nexport function isOrdinal(values) {\n for (const value of values) {\n if (value == null) continue;\n const type = typeof value;\n return type === \"string\" || type === \"boolean\";\n }\n}\n\nexport function isTemporal(values) {\n for (const value of values) {\n if (value == null) continue;\n return value instanceof Date;\n }\n}\n\n// Are these strings that might represent dates? This is stricter than ISO 8601\n// because we want to ignore false positives on numbers; for example, the string\n// \"1192\" is more likely to represent a number than a date even though it is\n// valid ISO 8601 representing 1192-01-01.\nexport function isTemporalString(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"string\" && isNaN(value) && isoParse(value);\n }\n}\n\n// Are these strings that might represent numbers? This is stricter than\n// coercion because we want to ignore false positives on e.g. empty strings.\nexport function isNumericString(values) {\n for (const value of values) {\n if (value == null) continue;\n if (typeof value !== \"string\") return false;\n if (!value.trim()) continue;\n return !isNaN(value);\n }\n}\n\nexport function isNumeric(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"number\";\n }\n}\n\n// Returns true if every non-null value in the specified iterable of values\n// passes the specified predicate, and there is at least one non-null value;\n// returns false if at least one non-null value does not pass the specified\n// predicate; otherwise returns undefined (as if all values are null).\nexport function isEvery(values, is) {\n let every;\n for (const value of values) {\n if (value == null) continue;\n if (!is(value)) return false;\n every = true;\n }\n return every;\n}\n\n// Mostly relies on d3-color, with a few extra color keywords. Currently this\n// strictly requires that the value be a string; we might want to apply string\n// coercion here, though note that d3-color instances would need to support\n// valueOf to work correctly with InternMap.\n// https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint\nexport function isColor(value) {\n if (typeof value !== \"string\") return false;\n value = value.toLowerCase().trim();\n return (\n value === \"none\" ||\n value === \"currentcolor\" ||\n (value.startsWith(\"url(\") && value.endsWith(\")\")) || // , e.g. pattern or gradient\n (value.startsWith(\"var(\") && value.endsWith(\")\")) || // CSS variable\n color(value) !== null\n );\n}\n\nexport function isOpacity(value) {\n return typeof value === \"number\" && ((0 <= value && value <= 1) || isNaN(value));\n}\n\nexport function isNoneish(value) {\n return value == null || isNone(value);\n}\n\nexport function isNone(value) {\n return /^\\s*none\\s*$/i.test(value);\n}\n\nexport function isRound(value) {\n return /^\\s*round\\s*$/i.test(value);\n}\n\nexport function maybeFrameAnchor(value = \"middle\") {\n return keyword(value, \"frameAnchor\", [\n \"middle\",\n \"top-left\",\n \"top\",\n \"top-right\",\n \"right\",\n \"bottom-right\",\n \"bottom\",\n \"bottom-left\",\n \"left\"\n ]);\n}\n\n// Like a sort comparator, returns a positive value if the given array of values\n// is in ascending order, a negative value if the values are in descending\n// order. Assumes monotonicity; only tests the first and last values.\nexport function orderof(values) {\n if (values == null) return;\n const first = values[0];\n const last = values[values.length - 1];\n return descending(first, last);\n}\n\n// Unlike {...defaults, ...options}, this ensures that any undefined (but\n// present) properties in options inherit the given default value.\nexport function inherit(options = {}, ...rest) {\n let o = options;\n for (const defaults of rest) {\n for (const key in defaults) {\n if (o[key] === undefined) {\n const value = defaults[key];\n if (o === options) o = {...o, [key]: value};\n else o[key] = value;\n }\n }\n }\n return o;\n}\n\n// Given an iterable of named things (objects with a name property), returns a\n// corresponding object with properties associated with the given name.\nexport function named(things) {\n console.warn(\"named iterables are deprecated; please use an object instead\");\n const names = new Set();\n return Object.fromEntries(\n Array.from(things, (thing) => {\n const {name} = thing;\n if (name == null) throw new Error(\"missing name\");\n const key = `${name}`;\n if (key === \"__proto__\") throw new Error(`illegal name: ${key}`);\n if (names.has(key)) throw new Error(`duplicate name: ${key}`);\n names.add(key);\n return [name, thing];\n })\n );\n}\n\nexport function maybeNamed(things) {\n return isIterable(things) ? named(things) : things;\n}\n","// Positional scales have associated axes, and for ordinal data, a point or band\n// scale is used instead of an ordinal scale.\nexport const position = Symbol(\"position\");\n\n// Color scales default to the turbo interpolator for quantitative data, and to\n// the Tableau10 scheme for ordinal data. Color scales may also have an\n// associated legend.\nexport const color = Symbol(\"color\");\n\n// Radius scales default to the sqrt type, have a default range of [0, 3], and a\n// default domain from 0 to the median first quartile of associated channels.\nexport const radius = Symbol(\"radius\");\n\n// Length scales default to the linear type, have a default range of [0, 12],\n// and a default domain from 0 to the median median of associated channels.\nexport const length = Symbol(\"length\");\n\n// Opacity scales have a default range of [0, 1], and a default domain from 0 to\n// the maximum value of associated channels.\nexport const opacity = Symbol(\"opacity\");\n\n// Symbol scales have a default range of categorical symbols.\nexport const symbol = Symbol(\"symbol\");\n\n// TODO Rather than hard-coding the list of known scale names, collect the names\n// and categories for each plot specification, so that custom marks can register\n// custom scales.\nexport const registry = new Map([\n [\"x\", position],\n [\"y\", position],\n [\"fx\", position],\n [\"fy\", position],\n [\"r\", radius],\n [\"color\", color],\n [\"opacity\", opacity],\n [\"symbol\", symbol],\n [\"length\", length]\n]);\n","import {symbolAsterisk, symbolDiamond2, symbolPlus, symbolSquare2, symbolTriangle2, symbolTimes} from \"d3\";\nimport {symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye} from \"d3\";\n\nexport const sqrt3 = Math.sqrt(3);\nexport const sqrt4_3 = 2 / sqrt3;\n\nconst symbolHexagon = {\n draw(context, size) {\n const rx = Math.sqrt(size / Math.PI),\n ry = rx * sqrt4_3,\n hy = ry / 2;\n context.moveTo(0, ry);\n context.lineTo(rx, hy);\n context.lineTo(rx, -hy);\n context.lineTo(0, -ry);\n context.lineTo(-rx, -hy);\n context.lineTo(-rx, hy);\n context.closePath();\n }\n};\n\nconst symbols = new Map([\n [\"asterisk\", symbolAsterisk],\n [\"circle\", symbolCircle],\n [\"cross\", symbolCross],\n [\"diamond\", symbolDiamond],\n [\"diamond2\", symbolDiamond2],\n [\"hexagon\", symbolHexagon],\n [\"plus\", symbolPlus],\n [\"square\", symbolSquare],\n [\"square2\", symbolSquare2],\n [\"star\", symbolStar],\n [\"times\", symbolTimes],\n [\"triangle\", symbolTriangle],\n [\"triangle2\", symbolTriangle2],\n [\"wye\", symbolWye]\n]);\n\nfunction isSymbolObject(value) {\n return value && typeof value.draw === \"function\";\n}\n\nexport function isSymbol(value) {\n if (isSymbolObject(value)) return true;\n if (typeof value !== \"string\") return false;\n return symbols.has(value.toLowerCase());\n}\n\nexport function maybeSymbol(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return symbol;\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return value;\n throw new Error(`invalid symbol: ${symbol}`);\n}\n\nexport function maybeSymbolChannel(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return [undefined, symbol];\n if (typeof symbol === \"string\") {\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return [undefined, value];\n }\n return [symbol, undefined];\n}\n","let warnings = 0;\n\nexport function consumeWarnings() {\n const w = warnings;\n warnings = 0;\n return w;\n}\n\nexport function warn(message) {\n console.warn(message);\n ++warnings;\n}\n","import {\n geoAlbers,\n geoAlbersUsa,\n geoAzimuthalEqualArea,\n geoAzimuthalEquidistant,\n geoClipRectangle,\n geoConicConformal,\n geoConicEqualArea,\n geoConicEquidistant,\n geoEqualEarth,\n geoEquirectangular,\n geoGnomonic,\n geoMercator,\n geoOrthographic,\n geoPath,\n geoStereographic,\n geoTransform,\n geoTransverseMercator\n} from \"d3\";\nimport {valueObject} from \"./channel.js\";\nimport {coerceNumbers, constant, isObject} from \"./options.js\";\nimport {warn} from \"./warnings.js\";\n\nconst pi = Math.PI;\nconst tau = 2 * pi;\nconst defaultAspectRatio = 0.618;\n\nexport function createProjection(\n {\n projection,\n inset: globalInset = 0,\n insetTop = globalInset,\n insetRight = globalInset,\n insetBottom = globalInset,\n insetLeft = globalInset\n } = {},\n dimensions\n) {\n if (projection == null) return;\n if (typeof projection.stream === \"function\") return projection; // d3 projection\n let options;\n let domain;\n let clip = \"frame\";\n\n // If the projection was specified as an object with additional options,\n // extract those. The order of precedence for insetTop (and other insets) is:\n // projection.insetTop, projection.inset, (global) insetTop, (global) inset.\n // Any other options on this object will be passed through to the initializer.\n if (isObject(projection)) {\n let inset;\n ({\n type: projection,\n domain,\n inset,\n insetTop = inset !== undefined ? inset : insetTop,\n insetRight = inset !== undefined ? inset : insetRight,\n insetBottom = inset !== undefined ? inset : insetBottom,\n insetLeft = inset !== undefined ? inset : insetLeft,\n clip = clip,\n ...options\n } = projection);\n if (projection == null) return;\n }\n\n // For named projections, retrieve the corresponding projection initializer.\n if (typeof projection !== \"function\") ({type: projection} = namedProjection(projection));\n\n // Compute the frame dimensions and invoke the projection initializer.\n const {width, height, marginLeft, marginRight, marginTop, marginBottom} = dimensions;\n const dx = width - marginLeft - marginRight - insetLeft - insetRight;\n const dy = height - marginTop - marginBottom - insetTop - insetBottom;\n projection = projection?.({width: dx, height: dy, clip, ...options});\n\n // The projection initializer might decide to not use a projection.\n if (projection == null) return;\n clip = maybePostClip(clip, marginLeft, marginTop, width - marginRight, height - marginBottom);\n\n // Translate the origin to the top-left corner, respecting margins and insets.\n let tx = marginLeft + insetLeft;\n let ty = marginTop + insetTop;\n let transform;\n\n // If a domain is specified, fit the projection to the frame.\n if (domain != null) {\n const [[x0, y0], [x1, y1]] = geoPath(projection).bounds(domain);\n const k = Math.min(dx / (x1 - x0), dy / (y1 - y0));\n if (k > 0) {\n tx -= (k * (x0 + x1) - dx) / 2;\n ty -= (k * (y0 + y1) - dy) / 2;\n transform = geoTransform({\n point(x, y) {\n this.stream.point(x * k + tx, y * k + ty);\n }\n });\n } else {\n warn(`Warning: the projection could not be fit to the specified domain; using the default scale.`);\n }\n }\n\n transform ??=\n tx === 0 && ty === 0\n ? identity()\n : geoTransform({\n point(x, y) {\n this.stream.point(x + tx, y + ty);\n }\n });\n\n return {stream: (s) => projection.stream(transform.stream(clip(s)))};\n}\n\nfunction namedProjection(projection) {\n switch (`${projection}`.toLowerCase()) {\n case \"albers-usa\":\n return scaleProjection(geoAlbersUsa, 0.7463, 0.4673);\n case \"albers\":\n return conicProjection(geoAlbers, 0.7463, 0.4673);\n case \"azimuthal-equal-area\":\n return scaleProjection(geoAzimuthalEqualArea, 4, 4);\n case \"azimuthal-equidistant\":\n return scaleProjection(geoAzimuthalEquidistant, tau, tau);\n case \"conic-conformal\":\n return conicProjection(geoConicConformal, tau, tau);\n case \"conic-equal-area\":\n return conicProjection(geoConicEqualArea, 6.1702, 2.9781);\n case \"conic-equidistant\":\n return conicProjection(geoConicEquidistant, 7.312, 3.6282);\n case \"equal-earth\":\n return scaleProjection(geoEqualEarth, 5.4133, 2.6347);\n case \"equirectangular\":\n return scaleProjection(geoEquirectangular, tau, pi);\n case \"gnomonic\":\n return scaleProjection(geoGnomonic, 3.4641, 3.4641);\n case \"identity\":\n return {type: identity};\n case \"reflect-y\":\n return {type: reflectY};\n case \"mercator\":\n return scaleProjection(geoMercator, tau, tau);\n case \"orthographic\":\n return scaleProjection(geoOrthographic, 2, 2);\n case \"stereographic\":\n return scaleProjection(geoStereographic, 2, 2);\n case \"transverse-mercator\":\n return scaleProjection(geoTransverseMercator, tau, tau);\n default:\n throw new Error(`unknown projection type: ${projection}`);\n }\n}\n\nfunction maybePostClip(clip, x1, y1, x2, y2) {\n if (clip === false || clip == null || typeof clip === \"number\") return (s) => s;\n if (clip === true) clip = \"frame\";\n switch (`${clip}`.toLowerCase()) {\n case \"frame\":\n return geoClipRectangle(x1, y1, x2, y2);\n default:\n throw new Error(`unknown projection clip type: ${clip}`);\n }\n}\n\nfunction scaleProjection(createProjection, kx, ky) {\n return {\n type: ({width, height, rotate, precision = 0.15, clip}) => {\n const projection = createProjection();\n if (precision != null) projection.precision?.(precision);\n if (rotate != null) projection.rotate?.(rotate);\n if (typeof clip === \"number\") projection.clipAngle?.(clip);\n projection.scale(Math.min(width / kx, height / ky));\n projection.translate([width / 2, height / 2]);\n return projection;\n },\n aspectRatio: ky / kx\n };\n}\n\nfunction conicProjection(createProjection, kx, ky) {\n const {type, aspectRatio} = scaleProjection(createProjection, kx, ky);\n return {\n type: (options) => {\n const {parallels, domain, width, height} = options;\n const projection = type(options);\n if (parallels != null) {\n projection.parallels(parallels);\n if (domain === undefined) {\n projection.fitSize([width, height], {type: \"Sphere\"});\n }\n }\n return projection;\n },\n aspectRatio\n };\n}\n\nconst identity = constant({stream: (stream) => stream});\n\nconst reflectY = constant(\n geoTransform({\n point(x, y) {\n this.stream.point(x, -y);\n }\n })\n);\n\n// Applies a point-wise projection to the given paired x and y channels.\n// Note: mutates values!\nexport function maybeProject(cx, cy, channels, values, context) {\n const x = channels[cx] && channels[cx].scale === \"x\";\n const y = channels[cy] && channels[cy].scale === \"y\";\n if (x && y) {\n project(cx, cy, values, context.projection);\n } else if (x) {\n throw new Error(`projection requires paired x and y channels; ${cx} is missing ${cy}`);\n } else if (y) {\n throw new Error(`projection requires paired x and y channels; ${cy} is missing ${cx}`);\n }\n}\n\nfunction project(cx, cy, values, projection) {\n const x = values[cx];\n const y = values[cy];\n const n = x.length;\n const X = (values[cx] = new Float64Array(n).fill(NaN));\n const Y = (values[cy] = new Float64Array(n).fill(NaN));\n let i;\n const stream = projection.stream({\n point(x, y) {\n X[i] = x;\n Y[i] = y;\n }\n });\n for (i = 0; i < n; ++i) {\n stream.point(x[i], y[i]);\n }\n}\n\n// When a named projection is specified, we can use its natural aspect ratio to\n// determine a good value for the projection’s height based on the desired\n// width. When we don’t have a way to know, the golden ratio is our best guess.\n// Due to a circular dependency (we need to know the height before we can\n// construct the projection), we have to test the raw projection option rather\n// than the materialized projection; therefore we must be extremely careful that\n// the logic of this function exactly matches Projection above!\nexport function projectionAspectRatio(projection, marks) {\n if (typeof projection?.stream === \"function\") return defaultAspectRatio;\n if (isObject(projection)) projection = projection.type;\n if (projection == null) return hasGeometry(marks) ? defaultAspectRatio : undefined;\n if (typeof projection !== \"function\") {\n const {aspectRatio} = namedProjection(projection);\n if (aspectRatio) return aspectRatio;\n }\n return defaultAspectRatio;\n}\n\n// Extract the (possibly) scaled values for the x and y channels, and apply the\n// projection if any.\nexport function applyPosition(channels, scales, context) {\n const {x, y} = channels;\n let position = {};\n if (x) position.x = x;\n if (y) position.y = y;\n position = valueObject(position, scales);\n if (context.projection) maybeProject(\"x\", \"y\", channels, position, context);\n if (x) position.x = coerceNumbers(position.x);\n if (y) position.y = coerceNumbers(position.y);\n return position;\n}\n\nfunction hasGeometry(marks) {\n for (const mark of marks) if (mark.channels.geometry) return true;\n return false;\n}\n","import {creator, select} from \"d3\";\nimport {createProjection} from \"./projection.js\";\n\nexport function createContext(options = {}, dimensions, className) {\n const {document = typeof window !== \"undefined\" ? window.document : undefined} = options;\n return {document, className, projection: createProjection(options, dimensions)};\n}\n\nexport function create(name, {document}) {\n return select(creator(name).call(document.documentElement));\n}\n","import {\n interpolateBlues,\n interpolateBrBG,\n interpolateBuGn,\n interpolateBuPu,\n interpolateGnBu,\n interpolateGreens,\n interpolateGreys,\n interpolateOranges,\n interpolateOrRd,\n interpolatePiYG,\n interpolatePRGn,\n interpolatePuBu,\n interpolatePuBuGn,\n interpolatePuOr,\n interpolatePuRd,\n interpolatePurples,\n interpolateRdBu,\n interpolateRdGy,\n interpolateRdPu,\n interpolateRdYlBu,\n interpolateRdYlGn,\n interpolateReds,\n interpolateSpectral,\n interpolateYlGn,\n interpolateYlGnBu,\n interpolateYlOrBr,\n interpolateYlOrRd,\n interpolateTurbo,\n interpolateViridis,\n interpolateMagma,\n interpolateInferno,\n interpolatePlasma,\n interpolateCividis,\n interpolateCubehelixDefault,\n interpolateWarm,\n interpolateCool,\n interpolateRainbow,\n interpolateSinebow,\n quantize,\n schemeAccent,\n schemeBlues,\n schemeBrBG,\n schemeBuGn,\n schemeBuPu,\n schemeCategory10,\n schemeDark2,\n schemeGnBu,\n schemeGreens,\n schemeGreys,\n schemeOranges,\n schemeOrRd,\n schemePaired,\n schemePastel1,\n schemePastel2,\n schemePiYG,\n schemePRGn,\n schemePuBu,\n schemePuBuGn,\n schemePuOr,\n schemePuRd,\n schemePurples,\n schemeRdBu,\n schemeRdGy,\n schemeRdPu,\n schemeRdYlBu,\n schemeRdYlGn,\n schemeReds,\n schemeSet1,\n schemeSet2,\n schemeSet3,\n schemeSpectral,\n schemeTableau10,\n schemeYlGn,\n schemeYlGnBu,\n schemeYlOrBr,\n schemeYlOrRd\n} from \"d3\";\n\nconst ordinalSchemes = new Map([\n // categorical\n [\"accent\", schemeAccent],\n [\"category10\", schemeCategory10],\n [\"dark2\", schemeDark2],\n [\"paired\", schemePaired],\n [\"pastel1\", schemePastel1],\n [\"pastel2\", schemePastel2],\n [\"set1\", schemeSet1],\n [\"set2\", schemeSet2],\n [\"set3\", schemeSet3],\n [\"tableau10\", schemeTableau10],\n\n // diverging\n [\"brbg\", scheme11(schemeBrBG, interpolateBrBG)],\n [\"prgn\", scheme11(schemePRGn, interpolatePRGn)],\n [\"piyg\", scheme11(schemePiYG, interpolatePiYG)],\n [\"puor\", scheme11(schemePuOr, interpolatePuOr)],\n [\"rdbu\", scheme11(schemeRdBu, interpolateRdBu)],\n [\"rdgy\", scheme11(schemeRdGy, interpolateRdGy)],\n [\"rdylbu\", scheme11(schemeRdYlBu, interpolateRdYlBu)],\n [\"rdylgn\", scheme11(schemeRdYlGn, interpolateRdYlGn)],\n [\"spectral\", scheme11(schemeSpectral, interpolateSpectral)],\n\n // reversed diverging (for temperature data)\n [\"burd\", scheme11r(schemeRdBu, interpolateRdBu)],\n [\"buylrd\", scheme11r(schemeRdYlBu, interpolateRdYlBu)],\n\n // sequential (single-hue)\n [\"blues\", scheme9(schemeBlues, interpolateBlues)],\n [\"greens\", scheme9(schemeGreens, interpolateGreens)],\n [\"greys\", scheme9(schemeGreys, interpolateGreys)],\n [\"oranges\", scheme9(schemeOranges, interpolateOranges)],\n [\"purples\", scheme9(schemePurples, interpolatePurples)],\n [\"reds\", scheme9(schemeReds, interpolateReds)],\n\n // sequential (multi-hue)\n [\"turbo\", schemei(interpolateTurbo)],\n [\"viridis\", schemei(interpolateViridis)],\n [\"magma\", schemei(interpolateMagma)],\n [\"inferno\", schemei(interpolateInferno)],\n [\"plasma\", schemei(interpolatePlasma)],\n [\"cividis\", schemei(interpolateCividis)],\n [\"cubehelix\", schemei(interpolateCubehelixDefault)],\n [\"warm\", schemei(interpolateWarm)],\n [\"cool\", schemei(interpolateCool)],\n [\"bugn\", scheme9(schemeBuGn, interpolateBuGn)],\n [\"bupu\", scheme9(schemeBuPu, interpolateBuPu)],\n [\"gnbu\", scheme9(schemeGnBu, interpolateGnBu)],\n [\"orrd\", scheme9(schemeOrRd, interpolateOrRd)],\n [\"pubu\", scheme9(schemePuBu, interpolatePuBu)],\n [\"pubugn\", scheme9(schemePuBuGn, interpolatePuBuGn)],\n [\"purd\", scheme9(schemePuRd, interpolatePuRd)],\n [\"rdpu\", scheme9(schemeRdPu, interpolateRdPu)],\n [\"ylgn\", scheme9(schemeYlGn, interpolateYlGn)],\n [\"ylgnbu\", scheme9(schemeYlGnBu, interpolateYlGnBu)],\n [\"ylorbr\", scheme9(schemeYlOrBr, interpolateYlOrBr)],\n [\"ylorrd\", scheme9(schemeYlOrRd, interpolateYlOrRd)],\n\n // cyclical\n [\"rainbow\", schemeicyclical(interpolateRainbow)],\n [\"sinebow\", schemeicyclical(interpolateSinebow)]\n]);\n\nfunction scheme9(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 1) return [scheme[3][1]]; // favor midpoint\n if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker\n n = Math.max(3, Math.floor(n));\n return n > 9 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11r(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse();\n };\n}\n\nfunction schemei(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.max(2, Math.floor(n)));\n}\n\nfunction schemeicyclical(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.floor(n) + 1).slice(0, -1);\n}\n\nexport function ordinalScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`);\n return ordinalSchemes.get(s);\n}\n\nexport function ordinalRange(scheme, length) {\n const s = ordinalScheme(scheme);\n const r = typeof s === \"function\" ? s({length}) : s;\n return r.length !== length ? r.slice(0, length) : r;\n}\n\n// If the specified domain contains only booleans (ignoring null and undefined),\n// returns a corresponding range where false is mapped to the low color and true\n// is mapped to the high color of the specified scheme.\nexport function maybeBooleanRange(domain, scheme = \"greys\") {\n const range = new Set();\n const [f, t] = ordinalRange(scheme, 2);\n for (const value of domain) {\n if (value == null) continue;\n if (value === true) range.add(t);\n else if (value === false) range.add(f);\n else return;\n }\n return [...range];\n}\n\nconst quantitativeSchemes = new Map([\n // diverging\n [\"brbg\", interpolateBrBG],\n [\"prgn\", interpolatePRGn],\n [\"piyg\", interpolatePiYG],\n [\"puor\", interpolatePuOr],\n [\"rdbu\", interpolateRdBu],\n [\"rdgy\", interpolateRdGy],\n [\"rdylbu\", interpolateRdYlBu],\n [\"rdylgn\", interpolateRdYlGn],\n [\"spectral\", interpolateSpectral],\n\n // reversed diverging (for temperature data)\n [\"burd\", (t) => interpolateRdBu(1 - t)],\n [\"buylrd\", (t) => interpolateRdYlBu(1 - t)],\n\n // sequential (single-hue)\n [\"blues\", interpolateBlues],\n [\"greens\", interpolateGreens],\n [\"greys\", interpolateGreys],\n [\"purples\", interpolatePurples],\n [\"reds\", interpolateReds],\n [\"oranges\", interpolateOranges],\n\n // sequential (multi-hue)\n [\"turbo\", interpolateTurbo],\n [\"viridis\", interpolateViridis],\n [\"magma\", interpolateMagma],\n [\"inferno\", interpolateInferno],\n [\"plasma\", interpolatePlasma],\n [\"cividis\", interpolateCividis],\n [\"cubehelix\", interpolateCubehelixDefault],\n [\"warm\", interpolateWarm],\n [\"cool\", interpolateCool],\n [\"bugn\", interpolateBuGn],\n [\"bupu\", interpolateBuPu],\n [\"gnbu\", interpolateGnBu],\n [\"orrd\", interpolateOrRd],\n [\"pubugn\", interpolatePuBuGn],\n [\"pubu\", interpolatePuBu],\n [\"purd\", interpolatePuRd],\n [\"rdpu\", interpolateRdPu],\n [\"ylgnbu\", interpolateYlGnBu],\n [\"ylgn\", interpolateYlGn],\n [\"ylorbr\", interpolateYlOrBr],\n [\"ylorrd\", interpolateYlOrRd],\n\n // cyclical\n [\"rainbow\", interpolateRainbow],\n [\"sinebow\", interpolateSinebow]\n]);\n\nexport function quantitativeScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`);\n return quantitativeSchemes.get(s);\n}\n\nconst divergingSchemes = new Set([\n \"brbg\",\n \"prgn\",\n \"piyg\",\n \"puor\",\n \"rdbu\",\n \"rdgy\",\n \"rdylbu\",\n \"rdylgn\",\n \"spectral\",\n \"burd\",\n \"buylrd\"\n]);\n\nexport function isDivergingScheme(scheme) {\n return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase());\n}\n","import {\n descending,\n extent,\n interpolateHcl,\n interpolateHsl,\n interpolateLab,\n interpolateNumber,\n interpolateRgb,\n interpolateRound,\n min,\n max,\n median,\n quantile,\n quantize,\n reverse as reverseof,\n scaleLinear,\n scaleLog,\n scalePow,\n scaleQuantile,\n scaleSymlog,\n scaleThreshold,\n scaleIdentity,\n ticks\n} from \"d3\";\nimport {positive, negative, finite} from \"../defined.js\";\nimport {arrayify, constant, orderof, slice, maybeNiceInterval, maybeRangeInterval} from \"../options.js\";\nimport {ordinalRange, quantitativeScheme} from \"./schemes.js\";\nimport {registry, radius, opacity, color, length} from \"./index.js\";\n\nexport const flip = (i) => (t) => i(1 - t);\nconst unit = [0, 1];\n\nconst interpolators = new Map([\n // numbers\n [\"number\", interpolateNumber],\n\n // color spaces\n [\"rgb\", interpolateRgb],\n [\"hsl\", interpolateHsl],\n [\"hcl\", interpolateHcl],\n [\"lab\", interpolateLab]\n]);\n\nexport function maybeInterpolator(interpolate) {\n const i = `${interpolate}`.toLowerCase();\n if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`);\n return interpolators.get(i);\n}\n\nexport function createScaleQ(\n key,\n scale,\n channels,\n {\n type,\n nice,\n clamp,\n zero,\n domain = inferAutoDomain(key, channels),\n unknown,\n round,\n scheme,\n interval,\n range = registry.get(key) === radius\n ? inferRadialRange(channels, domain)\n : registry.get(key) === length\n ? inferLengthRange(channels, domain)\n : registry.get(key) === opacity\n ? unit\n : undefined,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : type === \"cyclical\" ? \"rainbow\" : \"turbo\")\n : round\n ? interpolateRound\n : interpolateNumber,\n reverse\n }\n) {\n interval = maybeRangeInterval(interval, type);\n if (type === \"cyclical\" || type === \"sequential\") type = \"linear\"; // shorthand for color schemes\n reverse = !!reverse;\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n if (interpolate.length === 1) {\n if (reverse) {\n interpolate = flip(interpolate);\n reverse = false;\n }\n if (range === undefined) {\n range = Float64Array.from(domain, (_, i) => i / (domain.length - 1));\n if (range.length === 2) range = unit; // optimize common case of [0, 1]\n }\n scale.interpolate((range === unit ? constant : interpolatePiecewise)(interpolate));\n } else {\n scale.interpolate(interpolate);\n }\n\n // If a zero option is specified, we assume that the domain is numeric, and we\n // want to ensure that the domain crosses zero. However, note that the domain\n // may be reversed (descending) so we shouldn’t assume that the first value is\n // smaller than the last; and also it’s possible that the domain has more than\n // two values for a “poly” scale. And lastly be careful not to mutate input!\n if (zero) {\n const [min, max] = extent(domain);\n if (min > 0 || max < 0) {\n domain = slice(domain);\n if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0;\n // [2, 1] or [-2, -1]\n else domain[0] = 0; // [1, 2] or [-1, -2]\n }\n }\n\n if (reverse) domain = reverseof(domain);\n scale.domain(domain).unknown(unknown);\n if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain());\n if (range !== undefined) scale.range(range);\n if (clamp) scale.clamp(clamp);\n return {type, domain, range, scale, interpolate, interval};\n}\n\nfunction maybeNice(nice, type) {\n return nice === true ? undefined : typeof nice === \"number\" ? nice : maybeNiceInterval(nice, type);\n}\n\nexport function createScaleLinear(key, channels, options) {\n return createScaleQ(key, scaleLinear(), channels, options);\n}\n\nexport function createScaleSqrt(key, channels, options) {\n return createScalePow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScalePow(key, channels, {exponent = 1, ...options}) {\n return createScaleQ(key, scalePow().exponent(exponent), channels, {...options, type: \"pow\"});\n}\n\nexport function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) {\n return createScaleQ(key, scaleLog().base(base), channels, {...options, domain});\n}\n\nexport function createScaleSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleQ(key, scaleSymlog().constant(constant), channels, options);\n}\n\nexport function createScaleQuantile(\n key,\n channels,\n {\n range,\n quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead\n n = quantiles,\n scheme = \"rdylbu\",\n domain = inferQuantileDomain(channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n if (range === undefined) {\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n }\n if (domain.length > 0) {\n domain = scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles();\n }\n return createScaleThreshold(key, channels, {domain, range, reverse, unknown});\n}\n\nexport function createScaleQuantize(\n key,\n channels,\n {\n range,\n n = range === undefined ? 5 : (range = [...range]).length,\n scheme = \"rdylbu\",\n domain = inferAutoDomain(key, channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n const [min, max] = extent(domain);\n let thresholds;\n if (range === undefined) {\n thresholds = ticks(min, max, n); // approximate number of nice, round thresholds\n if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound\n if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound\n n = thresholds.length + 1;\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n } else {\n thresholds = quantize(interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range\n if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types\n }\n if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain\n return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown});\n}\n\nexport function createScaleThreshold(\n key,\n channels,\n {\n domain = [0], // explicit thresholds in ascending order\n unknown,\n scheme = \"rdylbu\",\n interpolate,\n range = interpolate !== undefined\n ? quantize(interpolate, domain.length + 1)\n : registry.get(key) === color\n ? ordinalRange(scheme, domain.length + 1)\n : undefined,\n reverse\n }\n) {\n domain = arrayify(domain);\n const sign = orderof(domain); // preserve descending domain\n if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`);\n if (reverse) range = reverseof(range); // domain ascending, so reverse range\n return {\n type: \"threshold\",\n scale: scaleThreshold(sign < 0 ? reverseof(domain) : domain, range === undefined ? [] : range).unknown(unknown),\n domain,\n range\n };\n}\n\nfunction isOrdered(domain, sign) {\n for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) {\n const s = descending(d, (d = domain[i]));\n if (s !== 0 && s !== sign) return false;\n }\n return true;\n}\n\nexport function createScaleIdentity() {\n return {type: \"identity\", scale: scaleIdentity()};\n}\n\nexport function inferDomain(channels, f = finite) {\n return channels.length\n ? [\n min(channels, ({value}) => (value === undefined ? value : min(value, f))),\n max(channels, ({value}) => (value === undefined ? value : max(value, f)))\n ]\n : [0, 1];\n}\n\nfunction inferAutoDomain(key, channels) {\n const type = registry.get(key);\n return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain)(channels);\n}\n\nfunction inferZeroDomain(channels) {\n return [0, channels.length ? max(channels, ({value}) => (value === undefined ? value : max(value, finite))) : 1];\n}\n\n// We don’t want the upper bound of the radial domain to be zero, as this would\n// be degenerate, so we ignore nonpositive values. We also don’t want the\n// maximum default radius to exceed 30px.\nfunction inferRadialRange(channels, domain) {\n const hint = channels.find(({radius}) => radius !== undefined);\n if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins\n const h25 = quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : quantile(value, 0.25, positive)));\n const range = domain.map((d) => 3 * Math.sqrt(d / h25));\n const k = 30 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\n// We want a length scale’s domain to go from zero to a positive value, and to\n// treat negative lengths if any as inverted vectors of equivalent magnitude. We\n// also don’t want the maximum default length to exceed 60px.\nfunction inferLengthRange(channels, domain) {\n const h50 = median(channels, ({value}) => (value === undefined ? NaN : median(value, Math.abs)));\n const range = domain.map((d) => (12 * d) / h50);\n const k = 60 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\nfunction inferLogDomain(channels) {\n for (const {value} of channels) {\n if (value !== undefined) {\n for (let v of value) {\n if (v > 0) return inferDomain(channels, positive);\n if (v < 0) return inferDomain(channels, negative);\n }\n }\n }\n return [1, 10];\n}\n\nfunction inferQuantileDomain(channels) {\n const domain = [];\n for (const {value} of channels) {\n if (value === undefined) continue;\n for (const v of value) domain.push(v);\n }\n return domain;\n}\n\nexport function interpolatePiecewise(interpolate) {\n return (i, j) => (t) => interpolate(i + t * (j - i));\n}\n","import {\n descending,\n interpolateNumber,\n interpolateRgb,\n piecewise,\n scaleDiverging,\n scaleDivergingLog,\n scaleDivergingPow,\n scaleDivergingSymlog\n} from \"d3\";\nimport {positive, negative} from \"../defined.js\";\nimport {quantitativeScheme} from \"./schemes.js\";\nimport {registry, color} from \"./index.js\";\nimport {inferDomain, maybeInterpolator, flip, interpolatePiecewise} from \"./quantitative.js\";\n\nfunction createScaleD(\n key,\n scale,\n transform,\n channels,\n {\n type,\n nice,\n clamp,\n domain = inferDomain(channels),\n unknown,\n pivot = 0,\n scheme,\n range,\n symmetric = true,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : \"rdbu\")\n : interpolateNumber,\n reverse\n }\n) {\n pivot = +pivot;\n let [min, max] = domain;\n if (descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse);\n min = Math.min(min, pivot);\n max = Math.max(max, pivot);\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n\n // If an explicit range is specified, promote it to a piecewise interpolator.\n if (range !== undefined) {\n interpolate =\n interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : piecewise(interpolate, range);\n }\n\n // Reverse before normalization.\n if (reverse) interpolate = flip(interpolate);\n\n // Normalize the interpolator for symmetric difference around the pivot.\n if (symmetric) {\n const mid = transform.apply(pivot);\n const mindelta = mid - transform.apply(min);\n const maxdelta = transform.apply(max) - mid;\n if (mindelta < maxdelta) min = transform.invert(mid - maxdelta);\n else if (mindelta > maxdelta) max = transform.invert(mid + mindelta);\n }\n\n scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate);\n if (clamp) scale.clamp(clamp);\n if (nice) scale.nice(nice);\n return {type, domain: [min, max], pivot, interpolate, scale};\n}\n\nexport function createScaleDiverging(key, channels, options) {\n return createScaleD(key, scaleDiverging(), transformIdentity, channels, options);\n}\n\nexport function createScaleDivergingSqrt(key, channels, options) {\n return createScaleDivergingPow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) {\n return createScaleD(key, scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, {\n ...options,\n type: \"diverging-pow\"\n });\n}\n\nexport function createScaleDivergingLog(\n key,\n channels,\n {base = 10, pivot = 1, domain = inferDomain(channels, pivot < 0 ? negative : positive), ...options}\n) {\n return createScaleD(key, scaleDivergingLog().base((base = +base)), transformLog, channels, {\n domain,\n pivot,\n ...options\n });\n}\n\nexport function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleD(\n key,\n scaleDivergingSymlog().constant((constant = +constant)),\n transformSymlog(constant),\n channels,\n options\n );\n}\n\nconst transformIdentity = {\n apply(x) {\n return x;\n },\n invert(x) {\n return x;\n }\n};\n\nconst transformLog = {\n apply: Math.log,\n invert: Math.exp\n};\n\nconst transformSqrt = {\n apply(x) {\n return Math.sign(x) * Math.sqrt(Math.abs(x));\n },\n invert(x) {\n return Math.sign(x) * (x * x);\n }\n};\n\nfunction transformPow(exponent) {\n return exponent === 0.5\n ? transformSqrt\n : {\n apply(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), exponent);\n },\n invert(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent);\n }\n };\n}\n\nfunction transformSymlog(constant) {\n return {\n apply(x) {\n return Math.sign(x) * Math.log1p(Math.abs(x / constant));\n },\n invert(x) {\n return Math.sign(x) * Math.expm1(Math.abs(x)) * constant;\n }\n };\n}\n","import {scaleTime, scaleUtc} from \"d3\";\nimport {createScaleQ} from \"./quantitative.js\";\n\nfunction createScaleT(key, scale, channels, options) {\n return createScaleQ(key, scale, channels, options);\n}\n\nexport function createScaleTime(key, channels, options) {\n return createScaleT(key, scaleTime(), channels, options);\n}\n\nexport function createScaleUtc(key, channels, options) {\n return createScaleT(key, scaleUtc(), channels, options);\n}\n","import {InternSet, extent, quantize, reverse as reverseof, sort, symbolsFill, symbolsStroke} from \"d3\";\nimport {scaleBand, scaleOrdinal, scalePoint, scaleImplicit} from \"d3\";\nimport {ascendingDefined} from \"../defined.js\";\nimport {isNoneish, map, maybeRangeInterval} from \"../options.js\";\nimport {maybeSymbol} from \"../symbol.js\";\nimport {registry, color, position, symbol} from \"./index.js\";\nimport {maybeBooleanRange, ordinalScheme, quantitativeScheme} from \"./schemes.js\";\n\n// This denotes an implicitly ordinal color scale: the scale type was not set,\n// but the associated values are strings or booleans. If the associated defined\n// values are entirely boolean, the range will default to greys. You can opt out\n// of this by setting the type explicitly.\nexport const ordinalImplicit = Symbol(\"ordinal\");\n\nfunction createScaleO(key, scale, channels, {type, interval, domain, range, reverse, hint}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n if (type === \"categorical\" || type === ordinalImplicit) type = \"ordinal\"; // shorthand for color schemes\n if (reverse) domain = reverseof(domain);\n scale.domain(domain);\n if (range !== undefined) {\n // If the range is specified as a function, pass it the domain.\n if (typeof range === \"function\") range = range(domain);\n scale.range(range);\n }\n return {type, domain, range, scale, hint, interval};\n}\n\nexport function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n let hint;\n if (registry.get(key) === symbol) {\n hint = inferSymbolHint(channels);\n range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol);\n } else if (registry.get(key) === color) {\n if (range === undefined && (type === \"ordinal\" || type === ordinalImplicit)) {\n range = maybeBooleanRange(domain, scheme);\n if (range !== undefined) scheme = undefined; // Don’t re-apply scheme.\n }\n if (scheme === undefined && range === undefined) {\n scheme = type === \"ordinal\" ? \"turbo\" : \"tableau10\";\n }\n if (scheme !== undefined) {\n if (range !== undefined) {\n const interpolate = quantitativeScheme(scheme);\n const t0 = range[0],\n d = range[1] - range[0];\n range = ({length: n}) => quantize((t) => interpolate(t0 + d * t), n);\n } else {\n range = ordinalScheme(scheme);\n }\n }\n }\n if (unknown === scaleImplicit) {\n throw new Error(`implicit unknown on ${key} scale is not supported`);\n }\n return createScaleO(key, scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint});\n}\n\nexport function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) {\n return maybeRound(scalePoint().align(align).padding(padding), channels, options, key);\n}\n\nexport function createScaleBand(\n key,\n channels,\n {\n align = 0.5,\n padding = 0.1,\n paddingInner = padding,\n paddingOuter = key === \"fx\" || key === \"fy\" ? 0 : padding,\n ...options\n }\n) {\n return maybeRound(\n scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter),\n channels,\n options,\n key\n );\n}\n\nfunction maybeRound(scale, channels, options, key) {\n let {round} = options;\n if (round !== undefined) scale.round((round = !!round));\n scale = createScaleO(key, scale, channels, options);\n scale.round = round; // preserve for autoScaleRound\n return scale;\n}\n\nfunction inferDomain(channels, interval, key) {\n const values = new InternSet();\n for (const {value, domain} of channels) {\n if (domain !== undefined) return domain(); // see channelDomain\n if (value === undefined) continue;\n for (const v of value) values.add(v);\n }\n if (interval !== undefined) {\n const [min, max] = extent(values).map(interval.floor, interval);\n return interval.range(min, interval.offset(max));\n }\n if (values.size > 10e3 && registry.get(key) === position) {\n throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`);\n }\n return sort(values, ascendingDefined);\n}\n\n// If all channels provide a consistent hint, propagate it to the scale.\nfunction inferHint(channels, key) {\n let value;\n for (const {hint} of channels) {\n const candidate = hint?.[key];\n if (candidate === undefined) continue; // no hint here\n if (value === undefined) value = candidate;\n // first hint\n else if (value !== candidate) return; // inconsistent hint\n }\n return value;\n}\n\nfunction inferSymbolHint(channels) {\n return {\n fill: inferHint(channels, \"fill\"),\n stroke: inferHint(channels, \"stroke\")\n };\n}\n\nfunction inferSymbolRange(hint) {\n return isNoneish(hint.fill) ? symbolsStroke : symbolsFill;\n}\n","import {\n isOrdinal,\n isTemporal,\n isTemporalString,\n isNumericString,\n isScaleOptions,\n map,\n slice,\n coerceNumbers,\n coerceDates\n} from \"./options.js\";\nimport {registry, color, position, radius, opacity, symbol, length} from \"./scales/index.js\";\nimport {\n createScaleLinear,\n createScaleSqrt,\n createScalePow,\n createScaleLog,\n createScaleSymlog,\n createScaleQuantile,\n createScaleQuantize,\n createScaleThreshold,\n createScaleIdentity\n} from \"./scales/quantitative.js\";\nimport {\n createScaleDiverging,\n createScaleDivergingSqrt,\n createScaleDivergingPow,\n createScaleDivergingLog,\n createScaleDivergingSymlog\n} from \"./scales/diverging.js\";\nimport {isDivergingScheme} from \"./scales/schemes.js\";\nimport {createScaleTime, createScaleUtc} from \"./scales/temporal.js\";\nimport {createScaleOrdinal, createScalePoint, createScaleBand, ordinalImplicit} from \"./scales/ordinal.js\";\nimport {maybeSymbol} from \"./symbol.js\";\nimport {warn} from \"./warnings.js\";\n\nexport function createScales(\n channelsByScale,\n {\n label: globalLabel,\n inset: globalInset = 0,\n insetTop: globalInsetTop = globalInset,\n insetRight: globalInsetRight = globalInset,\n insetBottom: globalInsetBottom = globalInset,\n insetLeft: globalInsetLeft = globalInset,\n round,\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n facet: {label: facetLabel = globalLabel} = {},\n ...options\n } = {}\n) {\n const scales = {};\n for (const [key, channels] of channelsByScale) {\n const scaleOptions = options[key];\n const scale = createScale(key, channels, {\n round: registry.get(key) === position ? round : undefined, // only for position\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n ...scaleOptions\n });\n if (scale) {\n // populate generic scale options (percent, transform, insets)\n let {\n label = key === \"fx\" || key === \"fy\" ? facetLabel : globalLabel,\n percent,\n transform,\n inset,\n insetTop = inset !== undefined ? inset : key === \"y\" ? globalInsetTop : 0, // not fy\n insetRight = inset !== undefined ? inset : key === \"x\" ? globalInsetRight : 0, // not fx\n insetBottom = inset !== undefined ? inset : key === \"y\" ? globalInsetBottom : 0, // not fy\n insetLeft = inset !== undefined ? inset : key === \"x\" ? globalInsetLeft : 0 // not fx\n } = scaleOptions || {};\n if (transform == null) transform = undefined;\n else if (typeof transform !== \"function\") throw new Error(\"invalid scale transform; not a function\");\n scale.percent = !!percent;\n scale.label = label === undefined ? inferScaleLabel(channels, scale) : label;\n scale.transform = transform;\n if (key === \"x\" || key === \"fx\") {\n scale.insetLeft = +insetLeft;\n scale.insetRight = +insetRight;\n } else if (key === \"y\" || key === \"fy\") {\n scale.insetTop = +insetTop;\n scale.insetBottom = +insetBottom;\n }\n scales[key] = scale;\n }\n }\n return scales;\n}\n\nexport function createScaleFunctions(scales) {\n return Object.fromEntries(\n Object.entries(scales)\n .filter(([, {scale}]) => scale) // drop identity scales\n .map(([name, {scale, type, interval, label}]) => {\n scale.type = type; // for axis\n if (interval != null) scale.interval = interval; // for axis\n if (label != null) scale.label = label; // for axis\n return [name, scale];\n })\n );\n}\n\n// Mutates scale.range!\nexport function autoScaleRange(scales, dimensions) {\n const {x, y, fx, fy} = scales;\n const superdimensions = fx || fy ? outerDimensions(dimensions) : dimensions;\n if (fx) autoScaleRangeX(fx, superdimensions);\n if (fy) autoScaleRangeY(fy, superdimensions);\n const subdimensions = fx || fy ? innerDimensions(scales, dimensions) : dimensions;\n if (x) autoScaleRangeX(x, subdimensions);\n if (y) autoScaleRangeY(y, subdimensions);\n}\n\n// Channels can have labels; if all the channels for a given scale are\n// consistently labeled (i.e., have the same value if not undefined), and the\n// corresponding scale doesn’t already have an explicit label, then the\n// channels’ label is promoted to the scale. This inferred label should have an\n// orientation-appropriate arrow added when used as an axis, but we don’t want\n// to add the arrow when the label is set explicitly as an option; so, the\n// inferred label is distinguished as an object with an “inferred” property.\nfunction inferScaleLabel(channels = [], scale) {\n let label;\n for (const {label: l} of channels) {\n if (l === undefined) continue;\n if (label === undefined) label = l;\n else if (label !== l) return;\n }\n if (label === undefined) return;\n // Ignore the implicit label for temporal scales if it’s simply “date”.\n if (isTemporalScale(scale) && /^(date|time|year)$/i.test(label)) return;\n if (!isOrdinalScale(scale) && scale.percent) label = `${label} (%)`;\n return {inferred: true, toString: () => label};\n}\n\n// Returns the dimensions of the outer frame; this is subdivided into facets\n// with the margins of each facet collapsing into the outer margins.\nexport function outerDimensions(dimensions) {\n const {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width,\n height,\n facet: {\n marginTop: facetMarginTop,\n marginRight: facetMarginRight,\n marginBottom: facetMarginBottom,\n marginLeft: facetMarginLeft\n }\n } = dimensions;\n return {\n marginTop: Math.max(marginTop, facetMarginTop),\n marginRight: Math.max(marginRight, facetMarginRight),\n marginBottom: Math.max(marginBottom, facetMarginBottom),\n marginLeft: Math.max(marginLeft, facetMarginLeft),\n width,\n height\n };\n}\n\n// Returns the dimensions of each facet.\nexport function innerDimensions({fx, fy}, dimensions) {\n const {marginTop, marginRight, marginBottom, marginLeft, width, height} = outerDimensions(dimensions);\n return {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width: fx ? fx.scale.bandwidth() + marginLeft + marginRight : width,\n height: fy ? fy.scale.bandwidth() + marginTop + marginBottom : height\n };\n}\n\nfunction autoScaleRangeX(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetLeft, insetRight} = scale;\n const {width, marginLeft = 0, marginRight = 0} = dimensions;\n const left = marginLeft + insetLeft;\n const right = width - marginRight - insetRight;\n scale.range = [left, Math.max(left, right)];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRangeY(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetTop, insetBottom} = scale;\n const {height, marginTop = 0, marginBottom = 0} = dimensions;\n const top = marginTop + insetTop;\n const bottom = height - marginBottom - insetBottom;\n scale.range = [Math.max(top, bottom), top];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n else scale.range.reverse();\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRound(scale) {\n if (scale.round === undefined && isBandScale(scale) && roundError(scale) <= 30) {\n scale.scale.round(true);\n }\n}\n\n// If we were to turn on rounding for this band or point scale, how much wasted\n// space would it introduce (on both ends of the range)? This must match\n// d3.scaleBand’s rounding behavior:\n// https://github.com/d3/d3-scale/blob/83555bd759c7314420bd4240642beda5e258db9e/src/band.js#L20-L32\nfunction roundError({scale}) {\n const n = scale.domain().length;\n const [start, stop] = scale.range();\n const paddingInner = scale.paddingInner ? scale.paddingInner() : 1;\n const paddingOuter = scale.paddingOuter ? scale.paddingOuter() : scale.padding();\n const m = n - paddingInner;\n const step = Math.abs(stop - start) / Math.max(1, m + paddingOuter * 2);\n return (step - Math.floor(step)) * m;\n}\n\nfunction piecewiseRange(scale) {\n const length = scale.scale.domain().length + isThresholdScale(scale);\n if (!(length > 2)) return scale.range;\n const [start, end] = scale.range;\n return Array.from({length}, (_, i) => start + (i / (length - 1)) * (end - start));\n}\n\nexport function normalizeScale(key, scale, hint) {\n return createScale(key, hint === undefined ? undefined : [{hint}], {...scale});\n}\n\nfunction createScale(key, channels = [], options = {}) {\n const type = inferScaleType(key, channels, options);\n\n // Warn for common misuses of implicit ordinal scales. We disable this test if\n // you specify a scale interval or if you set the domain or range explicitly,\n // since setting the domain or range (typically with a cardinality of more than\n // two) is another indication that you intended for the scale to be ordinal; we\n // also disable it for facet scales since these are always band scales.\n if (\n options.type === undefined &&\n options.domain === undefined &&\n options.range === undefined &&\n options.interval == null &&\n key !== \"fx\" &&\n key !== \"fy\" &&\n isOrdinalScale({type})\n ) {\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isTemporal))\n warn(\n `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isTemporalString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isNumericString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a \"linear\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n }\n\n options.type = type; // Mutates input!\n\n // Once the scale type is known, coerce the associated channel values and any\n // explicitly-specified domain to the expected type.\n switch (type) {\n case \"diverging\":\n case \"diverging-sqrt\":\n case \"diverging-pow\":\n case \"diverging-log\":\n case \"diverging-symlog\":\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n case \"sqrt\":\n case \"threshold\":\n case \"quantile\":\n case \"pow\":\n case \"log\":\n case \"symlog\":\n options = coerceType(channels, options, coerceNumbers);\n break;\n case \"identity\":\n switch (registry.get(key)) {\n case position:\n options = coerceType(channels, options, coerceNumbers);\n break;\n case symbol:\n options = coerceType(channels, options, coerceSymbols);\n break;\n }\n break;\n case \"utc\":\n case \"time\":\n options = coerceType(channels, options, coerceDates);\n break;\n }\n\n switch (type) {\n case \"diverging\":\n return createScaleDiverging(key, channels, options);\n case \"diverging-sqrt\":\n return createScaleDivergingSqrt(key, channels, options);\n case \"diverging-pow\":\n return createScaleDivergingPow(key, channels, options);\n case \"diverging-log\":\n return createScaleDivergingLog(key, channels, options);\n case \"diverging-symlog\":\n return createScaleDivergingSymlog(key, channels, options);\n case \"categorical\":\n case \"ordinal\":\n case ordinalImplicit:\n return createScaleOrdinal(key, channels, options);\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n return createScaleLinear(key, channels, options);\n case \"sqrt\":\n return createScaleSqrt(key, channels, options);\n case \"threshold\":\n return createScaleThreshold(key, channels, options);\n case \"quantile\":\n return createScaleQuantile(key, channels, options);\n case \"quantize\":\n return createScaleQuantize(key, channels, options);\n case \"pow\":\n return createScalePow(key, channels, options);\n case \"log\":\n return createScaleLog(key, channels, options);\n case \"symlog\":\n return createScaleSymlog(key, channels, options);\n case \"utc\":\n return createScaleUtc(key, channels, options);\n case \"time\":\n return createScaleTime(key, channels, options);\n case \"point\":\n return createScalePoint(key, channels, options);\n case \"band\":\n return createScaleBand(key, channels, options);\n case \"identity\":\n return registry.get(key) === position ? createScaleIdentity() : {type: \"identity\"};\n case undefined:\n return;\n default:\n throw new Error(`unknown scale type: ${type}`);\n }\n}\n\nfunction formatScaleType(type) {\n return typeof type === \"symbol\" ? type.description : type;\n}\n\n// A special type symbol when the x and y scales are replaced with a projection.\nconst typeProjection = {toString: () => \"projection\"};\n\nfunction inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) {\n // The facet scales are always band scales; this cannot be changed.\n if (key === \"fx\" || key === \"fy\") return \"band\";\n\n // If a projection is specified, the x- and y-scales are disabled; these\n // channels will be projected rather than scaled. (But still check that none\n // of the associated channels are incompatible with a projection.)\n if ((key === \"x\" || key === \"y\") && projection != null) type = typeProjection;\n\n // If a channel dictates a scale type, make sure that it is consistent with\n // the user-specified scale type (if any) and all other channels. For example,\n // barY requires x to be a band scale and disallows any other scale type.\n for (const {type: t} of channels) {\n if (t === undefined) continue;\n else if (type === undefined) type = t;\n else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`);\n }\n\n // If the scale, a channel, or user specified a (consistent) type, return it.\n if (type === typeProjection) return;\n if (type !== undefined) return type;\n\n // If there’s no data (and no type) associated with this scale, don’t create a scale.\n if (domain === undefined && !channels.some(({value}) => value !== undefined)) return;\n\n // Some scales have default types.\n const kind = registry.get(key);\n if (kind === radius) return \"sqrt\";\n if (kind === opacity || kind === length) return \"linear\";\n if (kind === symbol) return \"ordinal\";\n\n // If the domain or range has more than two values, assume it’s ordinal. You\n // can still use a “piecewise” (or “polylinear”) scale, but you must set the\n // type explicitly.\n if ((domain || range || []).length > 2) return asOrdinalType(kind);\n\n // Otherwise, infer the scale type from the data! Prefer the domain, if\n // present, over channels. (The domain and channels should be consistently\n // typed, and the domain is more explicit and typically much smaller.) We only\n // check the first defined value for expedience and simplicity; we expect\n // that the types are consistent.\n if (domain !== undefined) {\n if (isOrdinal(domain)) return asOrdinalType(kind);\n if (isTemporal(domain)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n }\n\n // If any channel is ordinal or temporal, it takes priority.\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isOrdinal)) return asOrdinalType(kind);\n if (values.some(isTemporal)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n}\n\n// Positional scales default to a point scale instead of an ordinal scale.\nfunction asOrdinalType(kind) {\n switch (kind) {\n case position:\n return \"point\";\n case color:\n return ordinalImplicit;\n default:\n return \"ordinal\";\n }\n}\n\nexport function isTemporalScale({type}) {\n return type === \"time\" || type === \"utc\";\n}\n\nexport function isOrdinalScale({type}) {\n return type === \"ordinal\" || type === \"point\" || type === \"band\" || type === ordinalImplicit;\n}\n\nexport function isThresholdScale({type}) {\n return type === \"threshold\";\n}\n\nfunction isBandScale({type}) {\n return type === \"point\" || type === \"band\";\n}\n\nexport function isDivergingScale({type}) {\n return /^diverging($|-)/.test(type);\n}\n\n// Certain marks have special behavior if a scale is collapsed, i.e. if the\n// domain is degenerate and represents only a single value such as [3, 3]; for\n// example, a rect will span the full extent of the chart along a collapsed\n// dimension (whereas a dot will simply be drawn in the center).\nexport function isCollapsed(scale) {\n if (scale === undefined) return true; // treat missing scale as collapsed\n const domain = scale.domain();\n const value = scale(domain[0]);\n for (let i = 1, n = domain.length; i < n; ++i) {\n if (scale(domain[i]) - value) {\n return false;\n }\n }\n return true;\n}\n\n// Mutates channel.value!\nfunction coerceType(channels, {domain, ...options}, coerceValues) {\n for (const c of channels) {\n if (c.value !== undefined) {\n c.value = coerceValues(c.value);\n }\n }\n return {\n domain: domain === undefined ? domain : coerceValues(domain),\n ...options\n };\n}\n\nfunction coerceSymbols(values) {\n return map(values, maybeSymbol);\n}\n\nexport function scale(options = {}) {\n let scale;\n for (const key in options) {\n if (!registry.has(key)) continue; // ignore unknown properties\n if (!isScaleOptions(options[key])) continue; // e.g., ignore {color: \"red\"}\n if (scale !== undefined) throw new Error(\"ambiguous scale definition; multiple scales found\");\n scale = exposeScale(normalizeScale(key, options[key]));\n }\n if (scale === undefined) throw new Error(\"invalid scale definition; no scale found\");\n return scale;\n}\n\nexport function exposeScales(scaleDescriptors) {\n return (key) => {\n if (!registry.has((key = `${key}`))) throw new Error(`unknown scale: ${key}`);\n return key in scaleDescriptors ? exposeScale(scaleDescriptors[key]) : undefined;\n };\n}\n\n// Note: axis- and legend-related properties (such as label, ticks and\n// tickFormat) are not included here as they do not affect the scale’s behavior.\nfunction exposeScale({scale, type, domain, range, interpolate, interval, transform, percent, pivot}) {\n if (type === \"identity\") return {type: \"identity\", apply: (d) => d, invert: (d) => d};\n const unknown = scale.unknown ? scale.unknown() : undefined;\n return {\n type,\n domain: slice(domain), // defensive copy\n ...(range !== undefined && {range: slice(range)}), // defensive copy\n ...(transform !== undefined && {transform}),\n ...(percent && {percent}), // only exposed if truthy\n ...(unknown !== undefined && {unknown}),\n ...(interval !== undefined && {interval}),\n\n // quantitative\n ...(interpolate !== undefined && {interpolate}),\n ...(scale.clamp && {clamp: scale.clamp()}),\n\n // diverging (always asymmetric; we never want to apply the symmetric transform twice)\n ...(pivot !== undefined && {pivot, symmetric: false}),\n\n // log, diverging-log\n ...(scale.base && {base: scale.base()}),\n\n // pow, diverging-pow\n ...(scale.exponent && {exponent: scale.exponent()}),\n\n // symlog, diverging-symlog\n ...(scale.constant && {constant: scale.constant()}),\n\n // band, point\n ...(scale.align && {align: scale.align(), round: scale.round()}),\n ...(scale.padding &&\n (scale.paddingInner\n ? {paddingInner: scale.paddingInner(), paddingOuter: scale.paddingOuter()}\n : {padding: scale.padding()})),\n ...(scale.bandwidth && {bandwidth: scale.bandwidth(), step: scale.step()}),\n\n // utilities\n apply: (t) => scale(t),\n ...(scale.invert && {invert: (t) => scale.invert(t)})\n };\n}\n","import {format as isoFormat} from \"isoformat\";\nimport {string} from \"./options.js\";\nimport {memoize1} from \"./memoize.js\";\n\nconst numberFormat = memoize1((locale) => {\n return new Intl.NumberFormat(locale);\n});\n\nconst monthFormat = memoize1((locale, month) => {\n return new Intl.DateTimeFormat(locale, {timeZone: \"UTC\", ...(month && {month})});\n});\n\nconst weekdayFormat = memoize1((locale, weekday) => {\n return new Intl.DateTimeFormat(locale, {timeZone: \"UTC\", ...(weekday && {weekday})});\n});\n\nexport function formatNumber(locale = \"en-US\") {\n const format = numberFormat(locale);\n return (i) => (i != null && !isNaN(i) ? format.format(i) : undefined);\n}\n\nexport function formatMonth(locale = \"en-US\", format = \"short\") {\n const fmt = monthFormat(locale, format);\n return (i) => (i != null && !isNaN((i = +new Date(Date.UTC(2000, +i)))) ? fmt.format(i) : undefined);\n}\n\nexport function formatWeekday(locale = \"en-US\", format = \"short\") {\n const fmt = weekdayFormat(locale, format);\n return (i) => (i != null && !isNaN((i = +new Date(Date.UTC(2001, 0, +i)))) ? fmt.format(i) : undefined);\n}\n\nexport function formatIsoDate(date) {\n return isoFormat(date, \"Invalid Date\");\n}\n\nexport function formatAuto(locale = \"en-US\") {\n const number = formatNumber(locale);\n return (v) => (v instanceof Date ? formatIsoDate : typeof v === \"number\" ? number : string)(v);\n}\n\n// TODO When Plot supports a top-level locale option, this should be removed\n// because it lacks context to know which locale to use; formatAuto should be\n// used instead whenever possible.\nexport const formatDefault = formatAuto();\n","export function memoize1(compute) {\n let cacheValue, cacheKeys;\n return (...keys) => {\n if (cacheKeys?.length !== keys.length || cacheKeys.some((k, i) => k !== keys[i])) {\n cacheKeys = keys;\n cacheValue = compute(...keys);\n }\n return cacheValue;\n };\n}\n","import {geoPath, group, namespaces} from \"d3\";\nimport {create} from \"./context.js\";\nimport {defined, nonempty} from \"./defined.js\";\nimport {formatDefault} from \"./format.js\";\nimport {\n string,\n number,\n maybeColorChannel,\n maybeNumberChannel,\n maybeKeyword,\n isNoneish,\n isNone,\n isRound,\n keyof\n} from \"./options.js\";\nimport {warn} from \"./warnings.js\";\n\nexport const offset = (typeof window !== \"undefined\" ? window.devicePixelRatio > 1 : typeof it === \"undefined\") ? 0 : 0.5; // prettier-ignore\n\nlet nextClipId = 0;\n\nfunction getClipId() {\n return `plot-clip-${++nextClipId}`;\n}\n\nexport function styles(\n mark,\n {\n title,\n href,\n ariaLabel: variaLabel,\n ariaDescription,\n ariaHidden,\n target,\n fill,\n fillOpacity,\n stroke,\n strokeWidth,\n strokeOpacity,\n strokeLinejoin,\n strokeLinecap,\n strokeMiterlimit,\n strokeDasharray,\n strokeDashoffset,\n opacity,\n mixBlendMode,\n paintOrder,\n pointerEvents,\n shapeRendering\n },\n {\n ariaLabel: cariaLabel,\n fill: defaultFill = \"currentColor\",\n fillOpacity: defaultFillOpacity,\n stroke: defaultStroke = \"none\",\n strokeOpacity: defaultStrokeOpacity,\n strokeWidth: defaultStrokeWidth,\n strokeLinecap: defaultStrokeLinecap,\n strokeLinejoin: defaultStrokeLinejoin,\n strokeMiterlimit: defaultStrokeMiterlimit,\n paintOrder: defaultPaintOrder\n }\n) {\n // Some marks don’t support fill (e.g., tick and rule).\n if (defaultFill === null) {\n fill = null;\n fillOpacity = null;\n }\n\n // Some marks don’t support stroke (e.g., image).\n if (defaultStroke === null) {\n stroke = null;\n strokeOpacity = null;\n }\n\n // Some marks default to fill with no stroke, while others default to stroke\n // with no fill. For example, bar and area default to fill, while dot and line\n // default to stroke. For marks that fill by default, the default fill only\n // applies if the stroke is (constant) none; if you set a stroke, then the\n // default fill becomes none. Similarly for marks that stroke by stroke, the\n // default stroke only applies if the fill is (constant) none.\n if (isNoneish(defaultFill)) {\n if (!isNoneish(defaultStroke) && !isNoneish(fill)) defaultStroke = \"none\";\n } else {\n if (isNoneish(defaultStroke) && !isNoneish(stroke)) defaultFill = \"none\";\n }\n\n const [vfill, cfill] = maybeColorChannel(fill, defaultFill);\n const [vfillOpacity, cfillOpacity] = maybeNumberChannel(fillOpacity, defaultFillOpacity);\n const [vstroke, cstroke] = maybeColorChannel(stroke, defaultStroke);\n const [vstrokeOpacity, cstrokeOpacity] = maybeNumberChannel(strokeOpacity, defaultStrokeOpacity);\n const [vopacity, copacity] = maybeNumberChannel(opacity);\n\n // For styles that have no effect if there is no stroke, only apply the\n // defaults if the stroke is not the constant none. (If stroke is a channel,\n // then cstroke will be undefined, but there’s still a stroke; hence we don’t\n // use isNoneish here.)\n if (!isNone(cstroke)) {\n if (strokeWidth === undefined) strokeWidth = defaultStrokeWidth;\n if (strokeLinecap === undefined) strokeLinecap = defaultStrokeLinecap;\n if (strokeLinejoin === undefined) strokeLinejoin = defaultStrokeLinejoin;\n\n // The default stroke miterlimit need not be applied if the current stroke\n // is the constant round; this only has effect on miter joins.\n if (strokeMiterlimit === undefined && !isRound(strokeLinejoin)) strokeMiterlimit = defaultStrokeMiterlimit;\n\n // The paint order only takes effect if there is both a fill and a stroke\n // (at least if we ignore markers, which no built-in marks currently use).\n if (!isNone(cfill) && paintOrder === undefined) paintOrder = defaultPaintOrder;\n }\n\n const [vstrokeWidth, cstrokeWidth] = maybeNumberChannel(strokeWidth);\n\n // Some marks don’t support fill (e.g., tick and rule).\n if (defaultFill !== null) {\n mark.fill = impliedString(cfill, \"currentColor\");\n mark.fillOpacity = impliedNumber(cfillOpacity, 1);\n }\n\n // Some marks don’t support stroke (e.g., image).\n if (defaultStroke !== null) {\n mark.stroke = impliedString(cstroke, \"none\");\n mark.strokeWidth = impliedNumber(cstrokeWidth, 1);\n mark.strokeOpacity = impliedNumber(cstrokeOpacity, 1);\n mark.strokeLinejoin = impliedString(strokeLinejoin, \"miter\");\n mark.strokeLinecap = impliedString(strokeLinecap, \"butt\");\n mark.strokeMiterlimit = impliedNumber(strokeMiterlimit, 4);\n mark.strokeDasharray = impliedString(strokeDasharray, \"none\");\n mark.strokeDashoffset = impliedString(strokeDashoffset, \"0\");\n }\n\n mark.target = string(target);\n mark.ariaLabel = string(cariaLabel);\n mark.ariaDescription = string(ariaDescription);\n mark.ariaHidden = string(ariaHidden);\n mark.opacity = impliedNumber(copacity, 1);\n mark.mixBlendMode = impliedString(mixBlendMode, \"normal\");\n mark.paintOrder = impliedString(paintOrder, \"normal\");\n mark.pointerEvents = impliedString(pointerEvents, \"auto\");\n mark.shapeRendering = impliedString(shapeRendering, \"auto\");\n\n return {\n title: {value: title, optional: true},\n href: {value: href, optional: true},\n ariaLabel: {value: variaLabel, optional: true},\n fill: {value: vfill, scale: \"auto\", optional: true},\n fillOpacity: {value: vfillOpacity, scale: \"auto\", optional: true},\n stroke: {value: vstroke, scale: \"auto\", optional: true},\n strokeOpacity: {value: vstrokeOpacity, scale: \"auto\", optional: true},\n strokeWidth: {value: vstrokeWidth, optional: true},\n opacity: {value: vopacity, scale: \"auto\", optional: true}\n };\n}\n\n// Applies the specified titles via selection.call.\nexport function applyTitle(selection, L) {\n if (L)\n selection\n .filter((i) => nonempty(L[i]))\n .append(\"title\")\n .call(applyText, L);\n}\n\n// Like applyTitle, but for grouped data (lines, areas).\nexport function applyTitleGroup(selection, L) {\n if (L)\n selection\n .filter(([i]) => nonempty(L[i]))\n .append(\"title\")\n .call(applyTextGroup, L);\n}\n\nexport function applyText(selection, T) {\n if (T) selection.text((i) => formatDefault(T[i]));\n}\n\nexport function applyTextGroup(selection, T) {\n if (T) selection.text(([i]) => formatDefault(T[i]));\n}\n\nexport function applyChannelStyles(\n selection,\n {target},\n {\n ariaLabel: AL,\n title: T,\n fill: F,\n fillOpacity: FO,\n stroke: S,\n strokeOpacity: SO,\n strokeWidth: SW,\n opacity: O,\n href: H\n }\n) {\n if (AL) applyAttr(selection, \"aria-label\", (i) => AL[i]);\n if (F) applyAttr(selection, \"fill\", (i) => F[i]);\n if (FO) applyAttr(selection, \"fill-opacity\", (i) => FO[i]);\n if (S) applyAttr(selection, \"stroke\", (i) => S[i]);\n if (SO) applyAttr(selection, \"stroke-opacity\", (i) => SO[i]);\n if (SW) applyAttr(selection, \"stroke-width\", (i) => SW[i]);\n if (O) applyAttr(selection, \"opacity\", (i) => O[i]);\n if (H) applyHref(selection, (i) => H[i], target);\n applyTitle(selection, T);\n}\n\nexport function applyGroupedChannelStyles(\n selection,\n {target},\n {\n ariaLabel: AL,\n title: T,\n fill: F,\n fillOpacity: FO,\n stroke: S,\n strokeOpacity: SO,\n strokeWidth: SW,\n opacity: O,\n href: H\n }\n) {\n if (AL) applyAttr(selection, \"aria-label\", ([i]) => AL[i]);\n if (F) applyAttr(selection, \"fill\", ([i]) => F[i]);\n if (FO) applyAttr(selection, \"fill-opacity\", ([i]) => FO[i]);\n if (S) applyAttr(selection, \"stroke\", ([i]) => S[i]);\n if (SO) applyAttr(selection, \"stroke-opacity\", ([i]) => SO[i]);\n if (SW) applyAttr(selection, \"stroke-width\", ([i]) => SW[i]);\n if (O) applyAttr(selection, \"opacity\", ([i]) => O[i]);\n if (H) applyHref(selection, ([i]) => H[i], target);\n applyTitleGroup(selection, T);\n}\n\nfunction groupAesthetics({\n ariaLabel: AL,\n title: T,\n fill: F,\n fillOpacity: FO,\n stroke: S,\n strokeOpacity: SO,\n strokeWidth: SW,\n opacity: O,\n href: H\n}) {\n return [AL, T, F, FO, S, SO, SW, O, H].filter((c) => c !== undefined);\n}\n\nexport function groupZ(I, Z, z) {\n const G = group(I, (i) => Z[i]);\n if (z === undefined && G.size > I.length >> 1) {\n warn(\n `Warning: the implicit z channel has high cardinality. This may occur when the fill or stroke channel is associated with quantitative data rather than ordinal or categorical data. You can suppress this warning by setting the z option explicitly; if this data represents a single series, set z to null.`\n );\n }\n return G.values();\n}\n\nexport function* groupIndex(I, position, {z}, channels) {\n const {z: Z} = channels; // group channel\n const A = groupAesthetics(channels); // aesthetic channels\n const C = [...position, ...A]; // all channels\n\n // Group the current index by Z (if any).\n for (const G of Z ? groupZ(I, Z, z) : [I]) {\n let Ag; // the A-values (aesthetics) of the current group, if any\n let Gg; // the current group index (a subset of G, and I), if any\n out: for (const i of G) {\n // If any channel has an undefined value for this index, skip it.\n for (const c of C) {\n if (!defined(c[i])) {\n if (Gg) Gg.push(-1);\n continue out;\n }\n }\n\n // Otherwise, if this is a new group, record the aesthetics for this\n // group. Yield the current group and start a new one.\n if (Ag === undefined) {\n if (Gg) yield Gg;\n (Ag = A.map((c) => keyof(c[i]))), (Gg = [i]);\n continue;\n }\n\n // Otherwise, add the current index to the current group. Then, if any of\n // the aesthetics don’t match the current group, yield the current group\n // and start a new group of the current index.\n Gg.push(i);\n for (let j = 0; j < A.length; ++j) {\n const k = keyof(A[j][i]);\n if (k !== Ag[j]) {\n yield Gg;\n (Ag = A.map((c) => keyof(c[i]))), (Gg = [i]);\n continue out;\n }\n }\n }\n\n // Yield the current group, if any.\n if (Gg) yield Gg;\n }\n}\n\n// TODO Accept other types of clips (paths, urls, x, y, other marks…)?\n// https://github.com/observablehq/plot/issues/181\nexport function maybeClip(clip) {\n if (clip === true) clip = \"frame\";\n else if (clip === false) clip = null;\n return maybeKeyword(clip, \"clip\", [\"frame\", \"sphere\"]);\n}\n\n// Note: may mutate selection.node!\nfunction applyClip(selection, mark, dimensions, context) {\n let clipUrl;\n switch (mark.clip) {\n case \"frame\": {\n const {width, height, marginLeft, marginRight, marginTop, marginBottom} = dimensions;\n const id = getClipId();\n clipUrl = `url(#${id})`;\n selection = create(\"svg:g\", context)\n .call((g) =>\n g\n .append(\"svg:clipPath\")\n .attr(\"id\", id)\n .append(\"rect\")\n .attr(\"x\", marginLeft)\n .attr(\"y\", marginTop)\n .attr(\"width\", width - marginRight - marginLeft)\n .attr(\"height\", height - marginTop - marginBottom)\n )\n .each(function () {\n this.appendChild(selection.node());\n selection.node = () => this; // Note: mutation!\n });\n break;\n }\n case \"sphere\": {\n const {projection} = context;\n if (!projection) throw new Error(`the \"sphere\" clip option requires a projection`);\n const id = getClipId();\n clipUrl = `url(#${id})`;\n selection\n .append(\"clipPath\")\n .attr(\"id\", id)\n .append(\"path\")\n .attr(\"d\", geoPath(projection)({type: \"Sphere\"}));\n break;\n }\n }\n // Here we’re careful to apply the ARIA attributes to the outer G element when\n // clipping is applied, and to apply the ARIA attributes before any other\n // attributes (for readability).\n applyAttr(selection, \"aria-label\", mark.ariaLabel);\n applyAttr(selection, \"aria-description\", mark.ariaDescription);\n applyAttr(selection, \"aria-hidden\", mark.ariaHidden);\n applyAttr(selection, \"clip-path\", clipUrl);\n}\n\n// Note: may mutate selection.node!\nexport function applyIndirectStyles(selection, mark, dimensions, context) {\n applyClip(selection, mark, dimensions, context);\n applyAttr(selection, \"fill\", mark.fill);\n applyAttr(selection, \"fill-opacity\", mark.fillOpacity);\n applyAttr(selection, \"stroke\", mark.stroke);\n applyAttr(selection, \"stroke-width\", mark.strokeWidth);\n applyAttr(selection, \"stroke-opacity\", mark.strokeOpacity);\n applyAttr(selection, \"stroke-linejoin\", mark.strokeLinejoin);\n applyAttr(selection, \"stroke-linecap\", mark.strokeLinecap);\n applyAttr(selection, \"stroke-miterlimit\", mark.strokeMiterlimit);\n applyAttr(selection, \"stroke-dasharray\", mark.strokeDasharray);\n applyAttr(selection, \"stroke-dashoffset\", mark.strokeDashoffset);\n applyAttr(selection, \"shape-rendering\", mark.shapeRendering);\n applyAttr(selection, \"paint-order\", mark.paintOrder);\n applyAttr(selection, \"pointer-events\", mark.pointerEvents);\n}\n\nexport function applyDirectStyles(selection, mark) {\n applyStyle(selection, \"mix-blend-mode\", mark.mixBlendMode);\n applyAttr(selection, \"opacity\", mark.opacity);\n}\n\nfunction applyHref(selection, href, target) {\n selection.each(function (i) {\n const h = href(i);\n if (h != null) {\n const a = this.ownerDocument.createElementNS(namespaces.svg, \"a\");\n a.setAttribute(\"fill\", \"inherit\");\n a.setAttributeNS(namespaces.xlink, \"href\", h);\n if (target != null) a.setAttribute(\"target\", target);\n this.parentNode.insertBefore(a, this).appendChild(this);\n }\n });\n}\n\nexport function applyAttr(selection, name, value) {\n if (value != null) selection.attr(name, value);\n}\n\nexport function applyStyle(selection, name, value) {\n if (value != null) selection.style(name, value);\n}\n\nexport function applyTransform(selection, mark, {x, y}, tx = offset, ty = offset) {\n tx += mark.dx;\n ty += mark.dy;\n if (x?.bandwidth) tx += x.bandwidth() / 2;\n if (y?.bandwidth) ty += y.bandwidth() / 2;\n if (tx || ty) selection.attr(\"transform\", `translate(${tx},${ty})`);\n}\n\nexport function impliedString(value, impliedValue) {\n if ((value = string(value)) !== impliedValue) return value;\n}\n\nexport function impliedNumber(value, impliedValue) {\n if ((value = number(value)) !== impliedValue) return value;\n}\n\n// https://www.w3.org/TR/CSS21/grammar.html\nconst validClassName =\n /^-?([_a-z]|[\\240-\\377]|\\\\[0-9a-f]{1,6}(\\r\\n|[ \\t\\r\\n\\f])?|\\\\[^\\r\\n\\f0-9a-f])([_a-z0-9-]|[\\240-\\377]|\\\\[0-9a-f]{1,6}(\\r\\n|[ \\t\\r\\n\\f])?|\\\\[^\\r\\n\\f0-9a-f])*$/i;\n\nexport function maybeClassName(name) {\n // The default should be changed whenever the default styles are changed, so\n // as to avoid conflict when multiple versions of Plot are on the page.\n if (name === undefined) return \"plot-d6a7b5\";\n name = `${name}`;\n if (!validClassName.test(name)) throw new Error(`invalid class name: ${name}`);\n return name;\n}\n\nexport function applyInlineStyles(selection, style) {\n if (typeof style === \"string\") {\n selection.property(\"style\", style);\n } else if (style != null) {\n for (const element of selection) {\n Object.assign(element.style, style);\n }\n }\n}\n\nexport function applyFrameAnchor({frameAnchor}, {width, height, marginTop, marginRight, marginBottom, marginLeft}) {\n return [\n /left$/.test(frameAnchor)\n ? marginLeft\n : /right$/.test(frameAnchor)\n ? width - marginRight\n : (marginLeft + width - marginRight) / 2,\n /^top/.test(frameAnchor)\n ? marginTop\n : /^bottom/.test(frameAnchor)\n ? height - marginBottom\n : (marginTop + height - marginBottom) / 2\n ];\n}\n","import {format, utcFormat} from \"d3\";\nimport {formatIsoDate} from \"./format.js\";\nimport {constant, isTemporal, string} from \"./options.js\";\nimport {isOrdinalScale} from \"./scales.js\";\n\nexport function inferFontVariant(scale) {\n return isOrdinalScale(scale) && scale.interval === undefined ? undefined : \"tabular-nums\";\n}\n\n// D3 doesn’t provide a tick format for ordinal scales; we want shorthand when\n// an ordinal domain is numbers or dates, and we want null to mean the empty\n// string, not the default identity format. TODO Remove this in favor of the\n// axis mark’s inferTickFormat.\nexport function maybeAutoTickFormat(tickFormat, domain) {\n return tickFormat === undefined\n ? isTemporal(domain)\n ? formatIsoDate\n : string\n : typeof tickFormat === \"function\"\n ? tickFormat\n : (typeof tickFormat === \"string\" ? (isTemporal(domain) ? utcFormat : format) : constant)(tickFormat);\n}\n","import {pathRound as path} from \"d3\";\nimport {inferFontVariant, maybeAutoTickFormat} from \"../axes.js\";\nimport {createContext, create} from \"../context.js\";\nimport {isNoneish, maybeColorChannel, maybeNumberChannel} from \"../options.js\";\nimport {isOrdinalScale, isThresholdScale} from \"../scales.js\";\nimport {applyInlineStyles, impliedString, maybeClassName} from \"../style.js\";\n\nfunction maybeScale(scale, key) {\n if (key == null) return key;\n const s = scale(key);\n if (!s) throw new Error(`scale not found: ${key}`);\n return s;\n}\n\nexport function legendSwatches(color, {opacity, ...options} = {}) {\n if (!isOrdinalScale(color) && !isThresholdScale(color))\n throw new Error(`swatches legend requires ordinal or threshold color scale (not ${color.type})`);\n return legendItems(color, options, (selection, scale, width, height) =>\n selection\n .append(\"svg\")\n .attr(\"width\", width)\n .attr(\"height\", height)\n .attr(\"fill\", scale.scale)\n .attr(\"fill-opacity\", maybeNumberChannel(opacity)[1])\n .append(\"rect\")\n .attr(\"width\", \"100%\")\n .attr(\"height\", \"100%\")\n );\n}\n\nexport function legendSymbols(\n symbol,\n {\n fill = symbol.hint?.fill !== undefined ? symbol.hint.fill : \"none\",\n fillOpacity = 1,\n stroke = symbol.hint?.stroke !== undefined ? symbol.hint.stroke : isNoneish(fill) ? \"currentColor\" : \"none\",\n strokeOpacity = 1,\n strokeWidth = 1.5,\n r = 4.5,\n ...options\n } = {},\n scale\n) {\n const [vf, cf] = maybeColorChannel(fill);\n const [vs, cs] = maybeColorChannel(stroke);\n const sf = maybeScale(scale, vf);\n const ss = maybeScale(scale, vs);\n const size = r * r * Math.PI;\n fillOpacity = maybeNumberChannel(fillOpacity)[1];\n strokeOpacity = maybeNumberChannel(strokeOpacity)[1];\n strokeWidth = maybeNumberChannel(strokeWidth)[1];\n return legendItems(symbol, options, (selection, scale, width, height) =>\n selection\n .append(\"svg\")\n .attr(\"viewBox\", \"-8 -8 16 16\")\n .attr(\"width\", width)\n .attr(\"height\", height)\n .attr(\"fill\", vf === \"color\" ? (d) => sf.scale(d) : cf)\n .attr(\"fill-opacity\", fillOpacity)\n .attr(\"stroke\", vs === \"color\" ? (d) => ss.scale(d) : cs)\n .attr(\"stroke-opacity\", strokeOpacity)\n .attr(\"stroke-width\", strokeWidth)\n .append(\"path\")\n .attr(\"d\", (d) => {\n const p = path();\n symbol.scale(d).draw(p, size);\n return p;\n })\n );\n}\n\nfunction legendItems(scale, options = {}, swatch) {\n let {\n columns,\n tickFormat,\n fontVariant = inferFontVariant(scale),\n // TODO label,\n swatchSize = 15,\n swatchWidth = swatchSize,\n swatchHeight = swatchSize,\n marginLeft = 0,\n className,\n style,\n width\n } = options;\n const context = createContext(options);\n className = maybeClassName(className);\n tickFormat = maybeAutoTickFormat(tickFormat, scale.domain);\n\n const swatches = create(\"div\", context).attr(\n \"class\",\n `${className}-swatches ${className}-swatches-${columns != null ? \"columns\" : \"wrap\"}`\n );\n\n let extraStyle;\n\n if (columns != null) {\n extraStyle = `.${className}-swatches-columns .${className}-swatch {\n display: flex;\n align-items: center;\n break-inside: avoid;\n padding-bottom: 1px;\n}\n.${className}-swatches-columns .${className}-swatch::before {\n flex-shrink: 0;\n}\n.${className}-swatches-columns .${className}-swatch-label {\n white-space: nowrap;\n overflow: hidden;\n text-overflow: ellipsis;\n}`;\n\n swatches\n .style(\"columns\", columns)\n .selectAll()\n .data(scale.domain)\n .enter()\n .append(\"div\")\n .attr(\"class\", `${className}-swatch`)\n .call(swatch, scale, swatchWidth, swatchHeight)\n .call((item) =>\n item.append(\"div\").attr(\"class\", `${className}-swatch-label`).attr(\"title\", tickFormat).text(tickFormat)\n );\n } else {\n extraStyle = `.${className}-swatches-wrap {\n display: flex;\n align-items: center;\n min-height: 33px;\n flex-wrap: wrap;\n}\n.${className}-swatches-wrap .${className}-swatch {\n display: inline-flex;\n align-items: center;\n margin-right: 1em;\n}`;\n\n swatches\n .selectAll()\n .data(scale.domain)\n .enter()\n .append(\"span\")\n .attr(\"class\", `${className}-swatch`)\n .call(swatch, scale, swatchWidth, swatchHeight)\n .append(function () {\n return this.ownerDocument.createTextNode(tickFormat.apply(this, arguments));\n });\n }\n\n return swatches\n .call((div) =>\n div.insert(\"style\", \"*\").text(\n `.${className}-swatches {\n font-family: system-ui, sans-serif;\n font-size: 10px;\n margin-bottom: 0.5em;\n}\n.${className}-swatch > svg {\n margin-right: 0.5em;\n overflow: visible;\n}\n${extraStyle}`\n )\n )\n .style(\"margin-left\", marginLeft ? `${+marginLeft}px` : null)\n .style(\"width\", width === undefined ? null : `${+width}px`)\n .style(\"font-variant\", impliedString(fontVariant, \"normal\"))\n .call(applyInlineStyles, style)\n .node();\n}\n","import {rgb} from \"d3\";\nimport {createContext} from \"./context.js\";\nimport {legendRamp} from \"./legends/ramp.js\";\nimport {legendSwatches, legendSymbols} from \"./legends/swatches.js\";\nimport {inherit, isScaleOptions} from \"./options.js\";\nimport {normalizeScale} from \"./scales.js\";\n\nconst legendRegistry = new Map([\n [\"symbol\", legendSymbols],\n [\"color\", legendColor],\n [\"opacity\", legendOpacity]\n]);\n\nexport function legend(options = {}) {\n for (const [key, value] of legendRegistry) {\n const scale = options[key];\n if (isScaleOptions(scale)) {\n // e.g., ignore {color: \"red\"}\n const context = createContext(options);\n let hint;\n // For symbol legends, pass a hint to the symbol scale.\n if (key === \"symbol\") {\n const {fill, stroke = fill === undefined && isScaleOptions(options.color) ? \"color\" : undefined} = options;\n hint = {fill, stroke};\n }\n return value(normalizeScale(key, scale, hint), legendOptions(context, scale, options), (key) =>\n isScaleOptions(options[key]) ? normalizeScale(key, options[key]) : null\n );\n }\n }\n throw new Error(\"unknown legend type; no scale found\");\n}\n\nexport function exposeLegends(scales, context, defaults = {}) {\n return (key, options) => {\n if (!legendRegistry.has(key)) throw new Error(`unknown legend type: ${key}`);\n if (!(key in scales)) return;\n return legendRegistry.get(key)(scales[key], legendOptions(context, defaults[key], options), (key) => scales[key]);\n };\n}\n\nfunction legendOptions({className, ...context}, {label, ticks, tickFormat} = {}, options) {\n return inherit(options, {className, ...context}, {label, ticks, tickFormat});\n}\n\nfunction legendColor(color, {legend = true, ...options}) {\n if (legend === true) legend = color.type === \"ordinal\" ? \"swatches\" : \"ramp\";\n if (color.domain === undefined) return;\n switch (`${legend}`.toLowerCase()) {\n case \"swatches\":\n return legendSwatches(color, options);\n case \"ramp\":\n return legendRamp(color, options);\n default:\n throw new Error(`unknown legend type: ${legend}`);\n }\n}\n\nfunction legendOpacity({type, interpolate, ...scale}, {legend = true, color = rgb(0, 0, 0), ...options}) {\n if (!interpolate) throw new Error(`${type} opacity scales are not supported`);\n if (legend === true) legend = \"ramp\";\n if (`${legend}`.toLowerCase() !== \"ramp\") throw new Error(`${legend} opacity legends are not supported`);\n return legendColor({type, ...scale, interpolate: interpolateOpacity(color)}, {legend, ...options});\n}\n\nfunction interpolateOpacity(color) {\n const {r, g, b} = rgb(color) || rgb(0, 0, 0); // treat invalid color as black\n return (t) => `rgba(${r},${g},${b},${t})`;\n}\n\nexport function createLegends(scales, context, options) {\n const legends = [];\n for (const [key, value] of legendRegistry) {\n const o = options[key];\n if (o?.legend && key in scales) {\n const legend = value(scales[key], legendOptions(context, scales[key], o), (key) => scales[key]);\n if (legend != null) legends.push(legend);\n }\n }\n return legends;\n}\n","import {quantize, interpolateNumber, piecewise, format, scaleBand, scaleLinear, axisBottom} from \"d3\";\nimport {inferFontVariant} from \"../axes.js\";\nimport {createContext, create} from \"../context.js\";\nimport {map, maybeNumberChannel} from \"../options.js\";\nimport {interpolatePiecewise} from \"../scales/quantitative.js\";\nimport {applyInlineStyles, impliedString, maybeClassName} from \"../style.js\";\n\nexport function legendRamp(color, options) {\n let {\n label = color.label,\n tickSize = 6,\n width = 240,\n height = 44 + tickSize,\n marginTop = 18,\n marginRight = 0,\n marginBottom = 16 + tickSize,\n marginLeft = 0,\n style,\n ticks = (width - marginLeft - marginRight) / 64,\n tickFormat,\n fontVariant = inferFontVariant(color),\n round = true,\n opacity,\n className\n } = options;\n const context = createContext(options);\n className = maybeClassName(className);\n opacity = maybeNumberChannel(opacity)[1];\n if (tickFormat === null) tickFormat = () => null;\n\n const svg = create(\"svg\", context)\n .attr(\"class\", `${className}-ramp`)\n .attr(\"font-family\", \"system-ui, sans-serif\")\n .attr(\"font-size\", 10)\n .attr(\"width\", width)\n .attr(\"height\", height)\n .attr(\"viewBox\", `0 0 ${width} ${height}`)\n .call((svg) =>\n // Warning: if you edit this, change defaultClassName.\n svg.append(\"style\").text(\n `.${className}-ramp {\n display: block;\n background: white;\n height: auto;\n height: intrinsic;\n max-width: 100%;\n overflow: visible;\n}\n.${className}-ramp text {\n white-space: pre;\n}`\n )\n )\n .call(applyInlineStyles, style);\n\n let tickAdjust = (g) => g.selectAll(\".tick line\").attr(\"y1\", marginTop + marginBottom - height);\n\n let x;\n\n // Some D3 scales use scale.interpolate, some scale.interpolator, and some\n // scale.round; this normalizes the API so it works with all scale types.\n const applyRange = round ? (x, range) => x.rangeRound(range) : (x, range) => x.range(range);\n\n const {type, domain, range, interpolate, scale, pivot} = color;\n\n // Continuous\n if (interpolate) {\n // Often interpolate is a “fixed” interpolator on the [0, 1] interval, as\n // with a built-in color scheme, but sometimes it is a function that takes\n // two arguments and is used in conjunction with the range.\n const interpolator =\n range === undefined\n ? interpolate\n : piecewise(interpolate.length === 1 ? interpolatePiecewise(interpolate) : interpolate, range);\n\n // Construct a D3 scale of the same type, but with a range that evenly\n // divides the horizontal extent of the legend. (In the common case, the\n // domain.length is two, and so the range is simply the extent.) For a\n // diverging scale, we need an extra point in the range for the pivot such\n // that the pivot is always drawn in the middle.\n x = applyRange(\n scale.copy(),\n quantize(\n interpolateNumber(marginLeft, width - marginRight),\n Math.min(domain.length + (pivot !== undefined), range === undefined ? Infinity : range.length)\n )\n );\n\n // Construct a 256×1 canvas, filling each pixel using the interpolator.\n const n = 256;\n const canvas = context.document.createElement(\"canvas\");\n canvas.width = n;\n canvas.height = 1;\n const context2 = canvas.getContext(\"2d\");\n for (let i = 0, j = n - 1; i < n; ++i) {\n context2.fillStyle = interpolator(i / j);\n context2.fillRect(i, 0, 1, 1);\n }\n\n svg\n .append(\"image\")\n .attr(\"opacity\", opacity)\n .attr(\"x\", marginLeft)\n .attr(\"y\", marginTop)\n .attr(\"width\", width - marginLeft - marginRight)\n .attr(\"height\", height - marginTop - marginBottom)\n .attr(\"preserveAspectRatio\", \"none\")\n .attr(\"xlink:href\", canvas.toDataURL());\n }\n\n // Threshold\n else if (type === \"threshold\") {\n const thresholds = domain;\n\n const thresholdFormat =\n tickFormat === undefined ? (d) => d : typeof tickFormat === \"string\" ? format(tickFormat) : tickFormat;\n\n // Construct a linear scale with evenly-spaced ticks for each of the\n // thresholds; the domain extends one beyond the threshold extent.\n x = applyRange(scaleLinear().domain([-1, range.length - 1]), [marginLeft, width - marginRight]);\n\n svg\n .append(\"g\")\n .attr(\"fill-opacity\", opacity)\n .selectAll()\n .data(range)\n .enter()\n .append(\"rect\")\n .attr(\"x\", (d, i) => x(i - 1))\n .attr(\"y\", marginTop)\n .attr(\"width\", (d, i) => x(i) - x(i - 1))\n .attr(\"height\", height - marginTop - marginBottom)\n .attr(\"fill\", (d) => d);\n\n ticks = map(thresholds, (_, i) => i);\n tickFormat = (i) => thresholdFormat(thresholds[i], i);\n }\n\n // Ordinal (hopefully!)\n else {\n x = applyRange(scaleBand().domain(domain), [marginLeft, width - marginRight]);\n\n svg\n .append(\"g\")\n .attr(\"fill-opacity\", opacity)\n .selectAll()\n .data(domain)\n .enter()\n .append(\"rect\")\n .attr(\"x\", x)\n .attr(\"y\", marginTop)\n .attr(\"width\", Math.max(0, x.bandwidth() - 1))\n .attr(\"height\", height - marginTop - marginBottom)\n .attr(\"fill\", scale);\n\n tickAdjust = () => {};\n }\n\n svg\n .append(\"g\")\n .attr(\"transform\", `translate(0,${height - marginBottom})`)\n .call(\n axisBottom(x)\n .ticks(Array.isArray(ticks) ? null : ticks, typeof tickFormat === \"string\" ? tickFormat : undefined)\n .tickFormat(typeof tickFormat === \"function\" ? tickFormat : undefined)\n .tickSize(tickSize)\n .tickValues(Array.isArray(ticks) ? ticks : null)\n )\n .attr(\"font-size\", null)\n .attr(\"font-family\", null)\n .attr(\"font-variant\", impliedString(fontVariant, \"normal\"))\n .call(tickAdjust)\n .call((g) => g.select(\".domain\").remove());\n\n if (label !== undefined) {\n svg\n .append(\"text\")\n .attr(\"x\", marginLeft)\n .attr(\"y\", marginTop - 6)\n .attr(\"fill\", \"currentColor\") // TODO move to stylesheet?\n .attr(\"font-weight\", \"bold\")\n .text(label);\n }\n\n return svg.node();\n}\n","import { select } from 'd3-selection';\nimport { legend } from '@observablehq/plot';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { IPlugin, PluginOptions } from '../index';\n\ninterface LegendOptions extends PluginOptions {\n enabled: boolean;\n itemSelector: string | null;\n label: string | null;\n width: number;\n}\n\nconst DEFAULT_SELECTOR = '#ch-plugin-legend';\n\nconst defaultOptions: LegendOptions = {\n // Whether to display the legend\n enabled: true,\n\n itemSelector: null,\n\n label: null,\n\n width: 130,\n};\n\nexport default class Legend implements IPlugin {\n name = 'Legend';\n\n calendar: CalHeatmap;\n\n root: any;\n\n shown: boolean;\n\n options: LegendOptions;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.root = null;\n this.shown = false;\n this.options = defaultOptions;\n }\n\n setup(pluginOptions?: Partial): void {\n this.options = { ...defaultOptions, ...pluginOptions };\n }\n\n paint(): Promise {\n const scaleOptions = this.calendar.options.options.scale;\n const { enabled, itemSelector } = this.options;\n\n if (!enabled || (itemSelector && select(itemSelector).empty())) {\n return this.destroy();\n }\n\n this.shown = true;\n\n this.root = select(\n itemSelector || this.calendar.options.options.itemSelector,\n );\n\n if (this.root.select(DEFAULT_SELECTOR).empty()) {\n this.root = this.root.append('div').attr('id', DEFAULT_SELECTOR.slice(1));\n } else {\n this.root = this.root.select(DEFAULT_SELECTOR);\n }\n\n // @ts-ignore\n const node = legend({\n ...scaleOptions,\n ...this.options,\n });\n\n this.root.selectAll('*').remove();\n this.root.append(() => node);\n\n return Promise.resolve();\n }\n\n destroy(): Promise {\n if (this.root !== null) {\n this.root.remove();\n this.root = null;\n }\n\n return Promise.resolve();\n }\n}\n"],"names":["fails","exec","error","descriptors","require$$0","Object","defineProperty","get","functionBindNative","test","bind","hasOwnProperty","NATIVE_BIND","FunctionPrototype","Function","prototype","call","uncurryThisWithBind","functionUncurryThis","fn","apply","arguments","isNullOrUndefined","it","$TypeError","TypeError","requireObjectCoercible","$Object","toObject","argument","require$$1","hasOwnProperty_1","hasOwn","key","DESCRIPTORS","getDescriptor","getOwnPropertyDescriptor","EXISTS","functionName","PROPER","name","CONFIGURABLE","configurable","makeBuiltIn$3","exports","documentAll","document","all","documentAll_1","IS_HTMLDDA","undefined","isCallable","check","Math","global","globalThis","window","self","this","defineGlobalProperty","value","writable","SHARED","sharedStore","store","require$$2","functionToString","toString","inspectSource","match","version","WeakMap","weakMapBasicDetection","String","isObject","objectDefineProperty","createElement","documentCreateElement","ie8DomDefine","a","v8PrototypeDefineBug","$String","anObject","functionCall","getBuiltIn","namespace","method","length","objectIsPrototypeOf","isPrototypeOf","engineUserAgent","navigator","userAgent","process","Deno","versions","v8","split","engineV8Version","V8_VERSION","symbolConstructorDetection","getOwnPropertySymbols","symbol","Symbol","sham","useSymbolAsUid","iterator","isSymbol","require$$3","$Symbol","tryToString","aCallable","getMethod","V","P","func","shared$3","sharedModule","push","mode","copyright","license","source","uncurryThis","id","postfix","random","uid","shared","NATIVE_SYMBOL","require$$4","USE_SYMBOL_AS_UID","require$$5","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","wellKnownSymbol","ordinaryToPrimitive","input","pref","val","valueOf","TO_PRIMITIVE","toPrimitive","result","exoticToPrim","toPropertyKey","IE8_DOM_DEFINE","V8_PROTOTYPE_DEFINE_BUG","$defineProperty","$getOwnPropertyDescriptor","ENUMERABLE","WRITABLE","f","O","Attributes","current","enumerable","set","has","createPropertyDescriptor","bitmap","definePropertyModule","createNonEnumerableProperty","object","keys","hiddenKeys","NATIVE_WEAK_MAP","sharedKey","require$$7","OBJECT_ALREADY_INITIALIZED","state","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","CONFIGURABLE_FUNCTION_NAME","require$$6","enforceInternalState","getInternalState","stringSlice","slice","replace","join","CONFIGURABLE_LENGTH","TEMPLATE","makeBuiltIn","makeBuiltInModule","options","getter","setter","arity","constructor","defineBuiltInAccessor","target","descriptor","FUNCTION_NAME_EXISTS","nameRE","regExpExec","objectGetOwnPropertyDescriptor","objectPropertyIsEnumerable","$propertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","classofRaw","classof","indexedObject","IndexedObject","toIndexedObject","propertyIsEnumerableModule","defineBuiltIn","simple","unsafe","nonConfigurable","nonWritable","ceil","floor","trunc","x","n","toIntegerOrInfinity","number","max","min","toLength","lengthOfArrayLike","obj","toAbsoluteIndex","index","integer","createMethod","IS_INCLUDES","$this","el","fromIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","i","enumBugKeys","internalObjectKeys","concat","objectGetOwnPropertyNames","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","ownKeys","getOwnPropertyDescriptorModule","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","toLowerCase","isForced_1","copyConstructorProperties","exceptions","_export","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","objectKeys","require$$8","$assign","assign","objectAssign","b","A","B","alphabet","forEach","chr","T","argumentsLength","S","j","toStringTagSupport","TO_STRING_TAG_SUPPORT","TO_STRING_TAG","CORRECT_ARGUMENTS","tag","tryGet","callee","engineIsNode","uncurryThisAccessor","aPossiblePrototype","objectSetPrototypeOf","setPrototypeOf","CORRECT_SETTER","Array","proto","__proto__","SPECIES","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","$location","defer","channel","port","isConstructor","called","aConstructor","functionApply","Reflect","functionBindContext","that","html","arraySlice","engineIsIos","validateArgumentsLength","passed","required","IS_IOS","require$$10","IS_NODE","require$$11","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","location","run","runner","eventListener","event","globalPostMessageDefer","postMessage","protocol","host","handler","args","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","task","Queue","head","tail","add","item","entry","next","notify","toggle","node","promise","then","engineIsIosPebble","Pebble","engineIsWebosWebkit","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","Promise","queueMicrotaskDescriptor","microtask","flush","parent","domain","exit","enter","resolve","createTextNode","observe","characterData","microtask_1","perform","promiseNativeConstructor","engineIsDeno","engineIsBrowser","NativePromiseConstructor","IS_BROWSER","IS_DENO","require$$9","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","promiseConstructorDetection","CONSTRUCTOR","REJECTION_EVENT","newPromiseCapability$2","PromiseCapability","C","reject","$$resolve","$$reject","newPromiseCapability","Internal","OwnPromiseCapability","nativeThen","$","setToStringTag","TAG","setSpecies","CONSTRUCTOR_NAME","Constructor","anInstance","Prototype","speciesConstructor","defaultConstructor","require$$14","require$$15","hostReportErrors","console","require$$17","require$$18","InternalStateModule","require$$19","require$$20","newPromiseCapabilityModule","require$$22","PROMISE","require$$21","NATIVE_PROMISE_SUBCLASSING","getInternalPromiseState","setInternalState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","isThenable","callReaction","reaction","exited","ok","fail","rejection","onHandleUnhandled","isReject","notified","reactions","onUnhandled","reason","initEvent","isUnhandled","emit","unwrap","internalReject","done","internalResolve","wrapper","executor","onFulfilled","onRejected","PromiseWrapper","wrap","iterators","Iterators","ITERATOR","ArrayPrototype","getIteratorMethod","isArrayIteratorMethod","getIterator","usingIterator","iteratorMethod","iteratorClose","kind","innerResult","innerError","Result","stopped","ResultPrototype","iterate","iterable","unboundFunction","iterFn","step","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","SAFE_CLOSING","iteratorWithReturn","return","from","checkCorrectnessOfIteration","SKIP_CLOSING","ITERATION_SUPPORT","promiseStaticsIncorrectIteration","capability","$promiseResolve","values","remaining","alreadyCalled","real","catch","race","r","promiseResolve","promiseCapability","defined","Number","isNaN","ascendingDefined","ascending","finite","isFinite","NaN","positive","negative","format","date","fallback","Date","hours","getUTCHours","minutes","getUTCMinutes","seconds","getUTCSeconds","milliseconds","getUTCMilliseconds","year","getUTCFullYear","pad","getUTCMonth","getUTCDate","width","padStart","re","parse","timeIntervals","Map","timeSecond","timeMinute","timeHour","timeDay","timeWeek","timeMonth","every","timeYear","timeMonday","timeTuesday","timeWednesday","timeThursday","timeFriday","timeSaturday","timeSunday","utcIntervals","utcSecond","utcMinute","utcHour","utcDay","utcWeek","utcMonth","utcYear","utcMonday","utcTuesday","utcWednesday","utcThursday","utcFriday","utcSaturday","utcSunday","maybeTimeInterval","interval","Error","maybeUtcInterval","TypedArray","getPrototypeOf","Uint8Array","objectToString","constant","coerceNumbers","map","coerceNumber","Float64Array","coerceDates","coerceDate","isoParse","maybeColorChannel","defaultValue","trim","startsWith","endsWith","color","isColor","maybeNumberChannel","arrayify","option","isScaleOptions","maybeInterval","isInteger","abs","d","offset","range","lo","hi","rangei","maybeRangeInterval","isOrdinal","isTemporal","isTemporalString","isNumericString","isNoneish","isNone","orderof","first","last","descending","position","radius","opacity","registry","sqrt4_3","sqrt","symbols","symbolAsterisk","symbolCircle","symbolCross","symbolDiamond","symbolDiamond2","draw","context","size","rx","PI","ry","hy","moveTo","lineTo","closePath","symbolPlus","symbolSquare","symbolSquare2","symbolStar","symbolTimes","symbolTriangle","symbolTriangle2","symbolWye","maybeSymbol","isSymbolObject","warn","message","pi","tau","createProjection","projection","inset","globalInset","insetTop","insetRight","insetBottom","insetLeft","dimensions","stream","clip","scaleProjection","geoAlbersUsa","conicProjection","geoAlbers","geoAzimuthalEqualArea","geoAzimuthalEquidistant","geoConicConformal","geoConicEqualArea","geoConicEquidistant","geoEqualEarth","geoEquirectangular","geoGnomonic","identity","reflectY","geoMercator","geoOrthographic","geoStereographic","geoTransverseMercator","namedProjection","height","marginLeft","marginRight","marginTop","marginBottom","dx","dy","x1","y1","x2","y2","s","geoClipRectangle","maybePostClip","transform","tx","ty","x0","y0","geoPath","bounds","k","geoTransform","point","y","kx","ky","rotate","precision","clipAngle","scale","translate","aspectRatio","parallels","fitSize","createContext","className","create","select","creator","documentElement","ordinalSchemes","schemeAccent","schemeCategory10","schemeDark2","schemePaired","schemePastel1","schemePastel2","schemeSet1","schemeSet2","schemeSet3","schemeTableau10","scheme11","schemeBrBG","interpolateBrBG","schemePRGn","interpolatePRGn","schemePiYG","interpolatePiYG","schemePuOr","interpolatePuOr","schemeRdBu","interpolateRdBu","schemeRdGy","interpolateRdGy","schemeRdYlBu","interpolateRdYlBu","schemeRdYlGn","interpolateRdYlGn","schemeSpectral","interpolateSpectral","scheme11r","scheme9","schemeBlues","interpolateBlues","schemeGreens","interpolateGreens","schemeGreys","interpolateGreys","schemeOranges","interpolateOranges","schemePurples","interpolatePurples","schemeReds","interpolateReds","schemei","interpolateTurbo","interpolateViridis","interpolateMagma","interpolateInferno","interpolatePlasma","interpolateCividis","interpolateCubehelixDefault","interpolateWarm","interpolateCool","schemeBuGn","interpolateBuGn","schemeBuPu","interpolateBuPu","schemeGnBu","interpolateGnBu","schemeOrRd","interpolateOrRd","schemePuBu","interpolatePuBu","schemePuBuGn","interpolatePuBuGn","schemePuRd","interpolatePuRd","schemeRdPu","interpolateRdPu","schemeYlGn","interpolateYlGn","schemeYlGnBu","interpolateYlGnBu","schemeYlOrBr","interpolateYlOrBr","schemeYlOrRd","interpolateYlOrRd","schemeicyclical","interpolateRainbow","interpolateSinebow","scheme","interpolate","quantize","t","reverse","ordinalScheme","ordinalRange","quantitativeSchemes","quantitativeScheme","divergingSchemes","Set","isDivergingScheme","flip","unit","interpolators","interpolateNumber","interpolateRgb","interpolateHsl","interpolateHcl","interpolateLab","maybeInterpolator","createScaleQ","channels","nice","clamp","zero","inferAutoDomain","unknown","round","inferRadialRange","inferLengthRange","interpolateRound","_","interpolatePiecewise","extent","sign","reverseof","maybeNiceInterval","maybeNice","createScalePow","exponent","scalePow","createScaleThreshold","isOrdered","scaleThreshold","inferDomain","inferZeroDomain","hint","find","h25","quantile","h50","median","inferLogDomain","v","inferQuantileDomain","createScaleD","pivot","symmetric","piecewise","mid","mindelta","maxdelta","invert","interpolator","createScaleDivergingPow","scaleDivergingPow","transformSqrt","pow","transformPow","createScaleDivergingSymlog","scaleDivergingSymlog","log1p","expm1","transformSymlog","transformIdentity","transformLog","log","exp","createScaleT","ordinalImplicit","createScaleO","createScaleOrdinal","fill","inferHint","stroke","inferSymbolHint","symbolsStroke","symbolsFill","inferSymbolRange","maybeBooleanRange","t0","scaleImplicit","scaleOrdinal","maybeRound","InternSet","sort","candidate","normalizeScale","typeProjection","some","asOrdinalType","filter","inferScaleType","isOrdinalScale","formatScaleType","coerceType","coerceSymbols","scaleDiverging","createScaleDiverging","createScaleDivergingSqrt","base","scaleDivergingLog","createScaleDivergingLog","scaleLinear","createScaleLinear","createScaleSqrt","quantiles","scaleQuantile","createScaleQuantile","thresholds","ticks","splice","pop","createScaleQuantize","scaleLog","createScaleLog","scaleSymlog","createScaleSymlog","scaleUtc","createScaleUtc","scaleTime","createScaleTime","align","padding","scalePoint","createScalePoint","paddingInner","paddingOuter","scaleBand","createScaleBand","scaleIdentity","createScale","description","coerceValues","c","numberFormat","compute","cacheValue","cacheKeys","memoize1","locale","Intl","NumberFormat","formatIsoDate","isoFormat","impliedString","impliedValue","formatNumber","formatAuto","validClassName","maybeClassName","applyInlineStyles","selection","style","property","element","inferFontVariant","maybeScale","legendItems","swatch","columns","tickFormat","fontVariant","swatchSize","swatchWidth","swatchHeight","utcFormat","maybeAutoTickFormat","swatches","attr","extraStyle","selectAll","append","text","ownerDocument","div","insert","legendRegistry","fillOpacity","strokeOpacity","strokeWidth","vf","cf","vs","cs","sf","ss","p","path","legendColor","legend","rgb","interpolateOpacity","legendOptions","label","rest","o","defaults","inherit","isThresholdScale","legendSwatches","tickSize","svg","tickAdjust","g","applyRange","rangeRound","copy","Infinity","canvas","context2","getContext","fillStyle","fillRect","toDataURL","thresholdFormat","bandwidth","axisBottom","isArray","tickValues","remove","legendRamp","DEFAULT_SELECTOR","defaultOptions","enabled","itemSelector","Legend","calendar","_classCallCheck","root","shown","pluginOptions","scaleOptions","_this$options","destroy"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140]} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.js b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.js new file mode 100644 index 0000000..ea0f4d8 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.js @@ -0,0 +1 @@ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e(require("d3-selection"),require("d3")):"function"==typeof define&&define.amd?define(["d3-selection","d3"],e):(t="undefined"!=typeof globalThis?globalThis:t||self).Legend=e(t.d3,t.d3)}(this,(function(t,e){"use strict";function n(t,e){for(var n=0;n0&&_[0]<4?1:+(_[0]+_[1])),!U&&wt&&(!(_=wt.match(/Edge\/(\d+)/))||_[1]>=74)&&(_=wt.match(/Chrome\/(\d+)/))&&(U=+_[1]);var Pt=U,Tt=Pt,$t=o,kt=B.String,Et=!!Object.getOwnPropertySymbols&&!$t((function(){var t=Symbol("symbol detection");return!kt(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&Tt&&Tt<41})),xt=Et&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,Rt=gt,Ct=C,Nt=yt,Bt=Object,qt=xt?function(t){return"symbol"==typeof t}:function(t){var e=Rt("Symbol");return Ct(e)&&Nt(e.prototype,Bt(t))},Dt=String,At=function(t){try{return Dt(t)}catch(t){return"Object"}},It=C,Gt=At,Lt=TypeError,zt=function(t){if(It(t))return t;throw new Lt(Gt(t)+" is not a function")},Ft=zt,Yt=p,_t=function(t,e){var n=t[e];return Yt(n)?void 0:Ft(n)},Ut=dt,Wt=C,Ht=Z,Vt=TypeError,Jt={exports:{}},Kt=L;(Jt.exports=function(t,e){return Kt[t]||(Kt[t]=void 0!==e?e:{})})("versions",[]).push({version:"3.34.0",mode:"global",copyright:"© 2014-2023 Denis Pushkarev (zloirock.ru)",license:"https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE",source:"https://github.com/zloirock/core-js"});var Xt=Jt.exports,Zt=f,Qt=0,te=Math.random(),ee=Zt(1..toString),ne=function(t){return"Symbol("+(void 0===t?"":t)+")_"+ee(++Qt+te,36)},re=Xt,oe=S,ie=ne,ae=Et,ue=xt,ce=B.Symbol,se=re("wks"),le=ue?ce.for||ce:ce&&ce.withoutSetter||ie,fe=function(t){return oe(se,t)||(se[t]=ae&&oe(ce,t)?ce[t]:le("Symbol."+t)),se[t]},pe=dt,de=Z,he=qt,me=_t,ge=function(t,e){var n,r;if("string"===e&&Wt(n=t.toString)&&!Ht(r=Ut(n,t)))return r;if(Wt(n=t.valueOf)&&!Ht(r=Ut(n,t)))return r;if("string"!==e&&Wt(n=t.toString)&&!Ht(r=Ut(n,t)))return r;throw new Vt("Can't convert object to primitive value")},ye=TypeError,ve=fe("toPrimitive"),be=function(t,e){if(!de(t)||he(t))return t;var n,r=me(t,ve);if(r){if(void 0===e&&(e="default"),n=pe(r,t,e),!de(n)||he(n))return n;throw new ye("Can't convert object to primitive value")}return void 0===e&&(e="number"),ge(t,e)},we=qt,Se=function(t){var e=be(t,"string");return we(e)?e:e+""},Oe=i,je=it,Me=at,Pe=lt,Te=Se,$e=TypeError,ke=Object.defineProperty,Ee=Object.getOwnPropertyDescriptor,xe="enumerable",Re="configurable",Ce="writable";Q.f=Oe?Me?function(t,e,n){if(Pe(t),e=Te(e),Pe(n),"function"==typeof t&&"prototype"===e&&"value"in n&&Ce in n&&!n[Ce]){var r=Ee(t,e);r&&r[Ce]&&(t[e]=n.value,n={configurable:Re in n?n[Re]:r[Re],enumerable:xe in n?n[xe]:r[xe],writable:!1})}return ke(t,e,n)}:ke:function(t,e,n){if(Pe(t),e=Te(e),Pe(n),je)try{return ke(t,e,n)}catch(t){}if("get"in n||"set"in n)throw new $e("Accessors not supported");return"value"in n&&(t[e]=n.value),t};var Ne,Be,qe,De=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}},Ae=Q,Ie=De,Ge=i?function(t,e,n){return Ae.f(t,e,Ie(1,n))}:function(t,e,n){return t[e]=n,t},Le=ne,ze=Xt("keys"),Fe={},Ye=J,_e=B,Ue=Z,We=Ge,He=S,Ve=L,Je=function(t){return ze[t]||(ze[t]=Le(t))},Ke=Fe,Xe="Object already initialized",Ze=_e.TypeError,Qe=_e.WeakMap;if(Ye||Ve.state){var tn=Ve.state||(Ve.state=new Qe);tn.get=tn.get,tn.has=tn.has,tn.set=tn.set,Ne=function(t,e){if(tn.has(t))throw new Ze(Xe);return e.facade=t,tn.set(t,e),e},Be=function(t){return tn.get(t)||{}},qe=function(t){return tn.has(t)}}else{var en=Je("state");Ke[en]=!0,Ne=function(t,e){if(He(t,en))throw new Ze(Xe);return e.facade=t,We(t,en,e),e},Be=function(t){return He(t,en)?t[en]:{}},qe=function(t){return He(t,en)}}var nn={set:Ne,get:Be,has:qe,enforce:function(t){return qe(t)?Be(t):Ne(t,{})},getterFor:function(t){return function(e){var n;if(!Ue(e)||(n=Be(e)).type!==t)throw new Ze("Incompatible receiver, "+t+" required");return n}}},rn=f,on=o,an=C,un=S,cn=i,sn=$.CONFIGURABLE,ln=W,fn=nn.enforce,pn=nn.get,dn=String,hn=Object.defineProperty,mn=rn("".slice),gn=rn("".replace),yn=rn([].join),vn=cn&&!on((function(){return 8!==hn((function(){}),"length",{value:8}).length})),bn=String(String).split("String"),wn=k.exports=function(t,e,n){"Symbol("===mn(dn(e),0,7)&&(e="["+gn(dn(e),/^Symbol\(([^)]*)\)/,"$1")+"]"),n&&n.getter&&(e="get "+e),n&&n.setter&&(e="set "+e),(!un(t,"name")||sn&&t.name!==e)&&(cn?hn(t,"name",{value:e,configurable:!0}):t.name=e),vn&&n&&un(n,"arity")&&t.length!==n.arity&&hn(t,"length",{value:n.arity});try{n&&un(n,"constructor")&&n.constructor?cn&&hn(t,"prototype",{writable:!1}):t.prototype&&(t.prototype=void 0)}catch(t){}var r=fn(t);return un(r,"source")||(r.source=yn(bn,"string"==typeof e?e:"")),t};Function.prototype.toString=wn((function(){return an(this)&&pn(this).source||ln(this)}),"toString");var Sn=k.exports,On=Sn,jn=Q,Mn=function(t,e,n){return n.get&&On(n.get,e,{getter:!0}),n.set&&On(n.set,e,{setter:!0}),jn.f(t,e,n)},Pn=i,Tn=$.EXISTS,$n=f,kn=Mn,En=Function.prototype,xn=$n(En.toString),Rn=/function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/,Cn=$n(Rn.exec);Pn&&!Tn&&kn(En,"name",{configurable:!0,get:function(){try{return Cn(Rn,xn(this))[1]}catch(t){return""}}});var Nn={},Bn={},qn={}.propertyIsEnumerable,Dn=Object.getOwnPropertyDescriptor,An=Dn&&!qn.call({1:2},1);Bn.f=An?function(t){var e=Dn(this,t);return!!e&&e.enumerable}:qn;var In=f,Gn=In({}.toString),Ln=In("".slice),zn=function(t){return Ln(Gn(t),8,-1)},Fn=o,Yn=zn,_n=Object,Un=f("".split),Wn=Fn((function(){return!_n("z").propertyIsEnumerable(0)}))?function(t){return"String"===Yn(t)?Un(t,""):_n(t)}:_n,Hn=Wn,Vn=m,Jn=function(t){return Hn(Vn(t))},Kn=i,Xn=dt,Zn=Bn,Qn=De,tr=Jn,er=Se,nr=S,rr=it,or=Object.getOwnPropertyDescriptor;Nn.f=Kn?or:function(t,e){if(t=tr(t),e=er(e),rr)try{return or(t,e)}catch(t){}if(nr(t,e))return Qn(!Xn(Zn.f,t,e),t[e])};var ir=C,ar=Q,ur=Sn,cr=A,sr=function(t,e,n,r){r||(r={});var o=r.enumerable,i=void 0!==r.name?r.name:e;if(ir(n)&&ur(n,i,r),r.global)o?t[e]=n:cr(e,n);else{try{r.unsafe?t[e]&&(o=!0):delete t[e]}catch(t){}o?t[e]=n:ar.f(t,e,{value:n,enumerable:!1,configurable:!r.nonConfigurable,writable:!r.nonWritable})}return t},lr={},fr=Math.ceil,pr=Math.floor,dr=Math.trunc||function(t){var e=+t;return(e>0?pr:fr)(e)},hr=function(t){var e=+t;return e!=e||0===e?0:dr(e)},mr=hr,gr=Math.max,yr=Math.min,vr=hr,br=Math.min,wr=function(t){return t>0?br(vr(t),9007199254740991):0},Sr=function(t){return wr(t.length)},Or=Jn,jr=function(t,e){var n=mr(t);return n<0?gr(n+e,0):yr(n,e)},Mr=Sr,Pr=function(t){return function(e,n,r){var o,i=Or(e),a=Mr(i),u=jr(r,a);if(t&&n!=n){for(;a>u;)if((o=i[u++])!=o)return!0}else for(;a>u;u++)if((t||u in i)&&i[u]===n)return t||u||0;return!t&&-1}},Tr={includes:Pr(!0),indexOf:Pr(!1)},$r=S,kr=Jn,Er=Tr.indexOf,xr=Fe,Rr=f([].push),Cr=function(t,e){var n,r=kr(t),o=0,i=[];for(n in r)!$r(xr,n)&&$r(r,n)&&Rr(i,n);for(;e.length>o;)$r(r,n=e[o++])&&(~Er(i,n)||Rr(i,n));return i},Nr=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],Br=Cr,qr=Nr.concat("length","prototype");lr.f=Object.getOwnPropertyNames||function(t){return Br(t,qr)};var Dr={};Dr.f=Object.getOwnPropertySymbols;var Ar=gt,Ir=lr,Gr=Dr,Lr=lt,zr=f([].concat),Fr=Ar("Reflect","ownKeys")||function(t){var e=Ir.f(Lr(t)),n=Gr.f;return n?zr(e,n(t)):e},Yr=S,_r=Fr,Ur=Nn,Wr=Q,Hr=o,Vr=C,Jr=/#|\.prototype\./,Kr=function(t,e){var n=Zr[Xr(t)];return n===to||n!==Qr&&(Vr(e)?Hr(e):!!e)},Xr=Kr.normalize=function(t){return String(t).replace(Jr,".").toLowerCase()},Zr=Kr.data={},Qr=Kr.NATIVE="N",to=Kr.POLYFILL="P",eo=Kr,no=B,ro=Nn.f,oo=Ge,io=sr,ao=A,uo=function(t,e,n){for(var r=_r(e),o=Wr.f,i=Ur.f,a=0;ao;)for(var u,c=Oo(arguments[o++]),s=i?Po(vo(c),i(c)):vo(c),l=s.length,f=0;l>f;)u=s[f++],ho&&!go(a,c,u)||(n[u]=c[u]);return n}:jo,$o=To;so({target:"Object",stat:!0,arity:2,forced:Object.assign!==$o},{assign:$o});var ko={};ko[fe("toStringTag")]="z";var Eo="[object z]"===String(ko),xo=Eo,Ro=C,Co=zn,No=fe("toStringTag"),Bo=Object,qo="Arguments"===Co(function(){return arguments}()),Do=xo?Co:function(t){var e,n,r;return void 0===t?"Undefined":null===t?"Null":"string"==typeof(n=function(t,e){try{return t[e]}catch(t){}}(e=Bo(t),No))?n:qo?Co(e):"Object"===(r=Co(e))&&Ro(e.callee)?"Arguments":r},Ao=Do,Io=Eo?{}.toString:function(){return"[object "+Ao(this)+"]"};Eo||sr(Object.prototype,"toString",Io,{unsafe:!0});var Go="process"===zn(B.process),Lo=f,zo=zt,Fo=C,Yo=String,_o=TypeError,Uo=function(t,e,n){try{return Lo(zo(Object.getOwnPropertyDescriptor(t,e)[n]))}catch(t){}},Wo=lt,Ho=function(t){if("object"==typeof t||Fo(t))return t;throw new _o("Can't set "+Yo(t)+" as a prototype")},Vo=Object.setPrototypeOf||("__proto__"in{}?function(){var t,e=!1,n={};try{(t=Uo(Object.prototype,"__proto__","set"))(n,[]),e=n instanceof Array}catch(t){}return function(n,r){return Wo(n),Ho(r),e?t(n,r):n.__proto__=r,n}}():void 0),Jo=Q.f,Ko=S,Xo=fe("toStringTag"),Zo=gt,Qo=Mn,ti=i,ei=fe("species"),ni=yt,ri=TypeError,oi=f,ii=o,ai=C,ui=Do,ci=W,si=function(){},li=[],fi=gt("Reflect","construct"),pi=/^\s*(?:class|function)\b/,di=oi(pi.exec),hi=!pi.test(si),mi=function(t){if(!ai(t))return!1;try{return fi(si,li,t),!0}catch(t){return!1}},gi=function(t){if(!ai(t))return!1;switch(ui(t)){case"AsyncFunction":case"GeneratorFunction":case"AsyncGeneratorFunction":return!1}try{return hi||!!di(pi,ci(t))}catch(t){return!0}};gi.sham=!0;var yi,vi,bi,wi,Si=!fi||ii((function(){var t;return mi(mi.call)||!mi(Object)||!mi((function(){t=!0}))||t}))?gi:mi,Oi=Si,ji=At,Mi=TypeError,Pi=lt,Ti=function(t){if(Oi(t))return t;throw new Mi(ji(t)+" is not a constructor")},$i=p,ki=fe("species"),Ei=a,xi=Function.prototype,Ri=xi.apply,Ci=xi.call,Ni="object"==typeof Reflect&&Reflect.apply||(Ei?Ci.bind(Ri):function(){return Ci.apply(Ri,arguments)}),Bi=zn,qi=f,Di=function(t){if("Function"===Bi(t))return qi(t)},Ai=zt,Ii=a,Gi=Di(Di.bind),Li=function(t,e){return Ai(t),void 0===e?t:Ii?Gi(t,e):function(){return t.apply(e,arguments)}},zi=gt("document","documentElement"),Fi=f([].slice),Yi=TypeError,_i=/(?:ipad|iphone|ipod).*applewebkit/i.test(vt),Ui=B,Wi=Ni,Hi=Li,Vi=C,Ji=S,Ki=o,Xi=zi,Zi=Fi,Qi=rt,ta=function(t,e){if(ti;i++)if((u=y(t[i]))&&Bc(Lc,u))return u;return new Gc(!1)}r=qc(t,o)}for(c=p?t.next:r.next;!(s=Ec(c,r)).done;){try{u=y(s.value)}catch(t){Ac(r,"throw",t)}if("object"==typeof u&&u&&Bc(Lc,u))return u}return new Gc(!1)},Fc=fe("iterator"),Yc=!1;try{var _c=0,Uc={next:function(){return{done:!!_c++}},return:function(){Yc=!0}};Uc[Fc]=function(){return this},Array.from(Uc,(function(){throw 2}))}catch(t){}var Wc=Wa,Hc=function(t,e){try{if(!e&&!Yc)return!1}catch(t){return!1}var n=!1;try{var r={};r[Fc]=function(){return{next:function(){return{done:n=!0}}}},t(r)}catch(t){}return n},Vc=cu.CONSTRUCTOR||!Hc((function(t){Wc.all(t).then(void 0,(function(){}))})),Jc=dt,Kc=zt,Xc=su,Zc=Ua,Qc=zc;so({target:"Promise",stat:!0,forced:Vc},{all:function(t){var e=this,n=Xc.f(e),r=n.resolve,o=n.reject,i=Zc((function(){var n=Kc(e.resolve),i=[],a=0,u=1;Qc(t,(function(t){var c=a++,s=!1;u++,Jc(n,e,t).then((function(t){s||(s=!0,i[c]=t,--u||r(i))}),o)})),--u||r(i)}));return i.error&&o(i.value),n.promise}});var ts=so,es=cu.CONSTRUCTOR,ns=Wa,rs=gt,os=C,is=sr,as=ns&&ns.prototype;if(ts({target:"Promise",proto:!0,forced:es,real:!0},{catch:function(t){return this.then(void 0,t)}}),os(ns)){var us=rs("Promise").prototype.catch;as.catch!==us&&is(as,"catch",us,{unsafe:!0})}var cs=dt,ss=zt,ls=su,fs=Ua,ps=zc;so({target:"Promise",stat:!0,forced:Vc},{race:function(t){var e=this,n=ls.f(e),r=n.reject,o=fs((function(){var o=ss(e.resolve);ps(t,(function(t){cs(o,e,t).then(n.resolve,r)}))}));return o.error&&r(o.value),n.promise}});var ds=dt,hs=su;so({target:"Promise",stat:!0,forced:cu.CONSTRUCTOR},{reject:function(t){var e=hs.f(this);return ds(e.reject,void 0,t),e.promise}});var ms=lt,gs=Z,ys=su,vs=so,bs=cu.CONSTRUCTOR,ws=function(t,e){if(ms(t),gs(e)&&e.constructor===t)return e;var n=ys.f(t);return(0,n.resolve)(e),n.promise};function Ss(t){return null!=t&&!Number.isNaN(t)}function Os(t,n){return+Ss(n)-+Ss(t)||e.ascending(t,n)}function js(t){return isFinite(t)?t:NaN}function Ms(t){return t>0&&isFinite(t)?t:NaN}function Ps(t){return t<0&&isFinite(t)?t:NaN}function Ts(t,e){if(t instanceof Date||(t=new Date(+t)),isNaN(t))return"function"==typeof e?e(t):e;const n=t.getUTCHours(),r=t.getUTCMinutes(),o=t.getUTCSeconds(),i=t.getUTCMilliseconds();return`${a=t.getUTCFullYear(),a<0?`-${$s(-a,6)}`:a>9999?`+${$s(a,6)}`:$s(a,4)}-${$s(t.getUTCMonth()+1,2)}-${$s(t.getUTCDate(),2)}${n||r||o||i?`T${$s(n,2)}:${$s(r,2)}${o||i?`:${$s(o,2)}${i?`.${$s(i,3)}`:""}`:""}Z`:""}`;var a}function $s(t,e){return`${t}`.padStart(e,"0")}gt("Promise"),vs({target:"Promise",stat:!0,forced:bs},{resolve:function(t){return ws(this,t)}});const ks=/^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/;function Es(t,e){return ks.test(t+="")?new Date(t):"function"==typeof e?e(t):e}const xs=new Map([["second",e.timeSecond],["minute",e.timeMinute],["hour",e.timeHour],["day",e.timeDay],["week",e.timeWeek],["month",e.timeMonth],["quarter",e.timeMonth.every(3)],["half",e.timeMonth.every(6)],["year",e.timeYear],["monday",e.timeMonday],["tuesday",e.timeTuesday],["wednesday",e.timeWednesday],["thursday",e.timeThursday],["friday",e.timeFriday],["saturday",e.timeSaturday],["sunday",e.timeSunday]]),Rs=new Map([["second",e.utcSecond],["minute",e.utcMinute],["hour",e.utcHour],["day",e.utcDay],["week",e.utcWeek],["month",e.utcMonth],["quarter",e.utcMonth.every(3)],["half",e.utcMonth.every(6)],["year",e.utcYear],["monday",e.utcMonday],["tuesday",e.utcTuesday],["wednesday",e.utcWednesday],["thursday",e.utcThursday],["friday",e.utcFriday],["saturday",e.utcSaturday],["sunday",e.utcSunday]]);function Cs(t){const e=xs.get(`${t}`.toLowerCase());if(!e)throw new Error(`unknown interval: ${t}`);return e}function Ns(t){const e=Rs.get(`${t}`.toLowerCase());if(!e)throw new Error(`unknown interval: ${t}`);return e}const Bs=Object.getPrototypeOf(Uint8Array),qs=Object.prototype.toString,Ds=t=>null==t?t:`${t}`,As=t=>()=>t;function Is(t){return t instanceof Bs?t:Us(t,Gs,Float64Array)}function Gs(t){return null==t?NaN:Number(t)}function Ls(t){return Us(t,zs)}function zs(t){return t instanceof Date&&!isNaN(t)?t:"string"==typeof t?Es(t):null==t||isNaN(t=+t)?void 0:new Date(t)}function Fs(t,n){return void 0===t&&(t=n),null===t?[void 0,"none"]:function(t){return"string"==typeof t&&(t=t.toLowerCase().trim(),"none"===t||"currentcolor"===t||t.startsWith("url(")&&t.endsWith(")")||t.startsWith("var(")&&t.endsWith(")")||null!==e.color(t))}(t)?[void 0,t]:[t,void 0]}function Ys(t,e){return void 0===t&&(t=e),null===t||"number"==typeof t?[void 0,t]:[t,void 0]}function _s(t){return null==t||t instanceof Array||t instanceof Bs?t:Array.from(t)}function Us(t,e,n=Array){return null==t?t:t instanceof n?t.map(e):n.from(t,e)}function Ws(t){return t?.toString===qs}function Hs(t){return Ws(t)&&(void 0!==t.type||void 0!==t.domain)}function Vs(t,n){if(null!=t){if("number"==typeof t){0Math.floor(t*n)/n,offset:t=>(t*n+1)/n,range:(t,r)=>e.range(Math.ceil(t*n),r*n).map((t=>t/n))}:{floor:t=>Math.floor(t/n)*n,offset:t=>t+n,range:(t,r)=>e.range(Math.ceil(t/n),r/n).map((t=>t*n))}}if("string"==typeof t)return("time"===n?Cs:Ns)(t);if("function"!=typeof t.floor)throw new Error("invalid interval; missing floor method");if("function"!=typeof t.offset)throw new Error("invalid interval; missing offset method");return t}}function Js(t,e){if((t=Vs(t,e))&&"function"!=typeof t.range)throw new Error("invalid interval: missing range method");return t}function Ks(t){for(const e of t){if(null==e)continue;const t=typeof e;return"string"===t||"boolean"===t}}function Xs(t){for(const e of t)if(null!=e)return e instanceof Date}function Zs(t){for(const e of t)if(null!=e)return"string"==typeof e&&isNaN(e)&&Es(e)}function Qs(t){for(const e of t)if(null!=e){if("string"!=typeof e)return!1;if(e.trim())return!isNaN(e)}}function tl(t){return null==t||function(t){return/^\s*none\s*$/i.test(t)}(t)}function el(t){if(null==t)return;const n=t[0],r=t[t.length-1];return e.descending(n,r)}const nl=Symbol("position"),rl=Symbol("color"),ol=Symbol("radius"),il=Symbol("length"),al=Symbol("opacity"),ul=Symbol("symbol"),cl=new Map([["x",nl],["y",nl],["fx",nl],["fy",nl],["r",ol],["color",rl],["opacity",al],["symbol",ul],["length",il]]),sl=2/Math.sqrt(3),ll={draw(t,e){const n=Math.sqrt(e/Math.PI),r=n*sl,o=r/2;t.moveTo(0,r),t.lineTo(n,o),t.lineTo(n,-o),t.lineTo(0,-r),t.lineTo(-n,-o),t.lineTo(-n,o),t.closePath()}},fl=new Map([["asterisk",e.symbolAsterisk],["circle",e.symbolCircle],["cross",e.symbolCross],["diamond",e.symbolDiamond],["diamond2",e.symbolDiamond2],["hexagon",ll],["plus",e.symbolPlus],["square",e.symbolSquare],["square2",e.symbolSquare2],["star",e.symbolStar],["times",e.symbolTimes],["triangle",e.symbolTriangle],["triangle2",e.symbolTriangle2],["wye",e.symbolWye]]);function pl(t){if(null==t||function(t){return t&&"function"==typeof t.draw}(t))return t;const e=fl.get(`${t}`.toLowerCase());if(e)return e;throw new Error(`invalid symbol: ${t}`)}function dl(t){console.warn(t)}const hl=Math.PI,ml=2*hl;function gl({projection:t,inset:n=0,insetTop:r=n,insetRight:o=n,insetBottom:i=n,insetLeft:a=n}={},u){if(null==t)return;if("function"==typeof t.stream)return t;let c,s,l="frame";if(Ws(t)){let e;if(({type:t,domain:s,inset:e,insetTop:r=(void 0!==e?e:r),insetRight:o=(void 0!==e?e:o),insetBottom:i=(void 0!==e?e:i),insetLeft:a=(void 0!==e?e:a),clip:l=l,...c}=t),null==t)return}"function"!=typeof t&&({type:t}=function(t){switch(`${t}`.toLowerCase()){case"albers-usa":return yl(e.geoAlbersUsa,.7463,.4673);case"albers":return vl(e.geoAlbers,.7463,.4673);case"azimuthal-equal-area":return yl(e.geoAzimuthalEqualArea,4,4);case"azimuthal-equidistant":return yl(e.geoAzimuthalEquidistant,ml,ml);case"conic-conformal":return vl(e.geoConicConformal,ml,ml);case"conic-equal-area":return vl(e.geoConicEqualArea,6.1702,2.9781);case"conic-equidistant":return vl(e.geoConicEquidistant,7.312,3.6282);case"equal-earth":return yl(e.geoEqualEarth,5.4133,2.6347);case"equirectangular":return yl(e.geoEquirectangular,ml,hl);case"gnomonic":return yl(e.geoGnomonic,3.4641,3.4641);case"identity":return{type:bl};case"reflect-y":return{type:wl};case"mercator":return yl(e.geoMercator,ml,ml);case"orthographic":return yl(e.geoOrthographic,2,2);case"stereographic":return yl(e.geoStereographic,2,2);case"transverse-mercator":return yl(e.geoTransverseMercator,ml,ml);default:throw new Error(`unknown projection type: ${t}`)}}(t));const{width:f,height:p,marginLeft:d,marginRight:h,marginTop:m,marginBottom:g}=u,y=f-d-h-a-o,v=p-m-g-r-i;if(t=t?.({width:y,height:v,clip:l,...c}),null==t)return;l=function(t,n,r,o,i){if(!1===t||null==t||"number"==typeof t)return t=>t;!0===t&&(t="frame");if("frame"===`${t}`.toLowerCase())return e.geoClipRectangle(n,r,o,i);throw new Error(`unknown projection clip type: ${t}`)}(l,d,m,f-h,p-g);let b,w=d+a,S=m+r;if(null!=s){const[[n,r],[o,i]]=e.geoPath(t).bounds(s),a=Math.min(y/(o-n),v/(i-r));a>0?(w-=(a*(n+o)-y)/2,S-=(a*(r+i)-v)/2,b=e.geoTransform({point(t,e){this.stream.point(t*a+w,e*a+S)}})):dl("Warning: the projection could not be fit to the specified domain; using the default scale.")}return b??=0===w&&0===S?bl():e.geoTransform({point(t,e){this.stream.point(t+w,e+S)}}),{stream:e=>t.stream(b.stream(l(e)))}}function yl(t,e,n){return{type:({width:r,height:o,rotate:i,precision:a=.15,clip:u})=>{const c=t();return null!=a&&c.precision?.(a),null!=i&&c.rotate?.(i),"number"==typeof u&&c.clipAngle?.(u),c.scale(Math.min(r/e,o/n)),c.translate([r/2,o/2]),c},aspectRatio:n/e}}function vl(t,e,n){const{type:r,aspectRatio:o}=yl(t,e,n);return{type:t=>{const{parallels:e,domain:n,width:o,height:i}=t,a=r(t);return null!=e&&(a.parallels(e),void 0===n&&a.fitSize([o,i],{type:"Sphere"})),a},aspectRatio:o}}const bl=As({stream:t=>t}),wl=As(e.geoTransform({point(t,e){this.stream.point(t,-e)}}));function Sl(t={},e,n){const{document:r=("undefined"!=typeof window?window.document:void 0)}=t;return{document:r,className:n,projection:gl(t,e)}}function Ol(t,{document:n}){return e.select(e.creator(t).call(n.documentElement))}const jl=new Map([["accent",e.schemeAccent],["category10",e.schemeCategory10],["dark2",e.schemeDark2],["paired",e.schemePaired],["pastel1",e.schemePastel1],["pastel2",e.schemePastel2],["set1",e.schemeSet1],["set2",e.schemeSet2],["set3",e.schemeSet3],["tableau10",e.schemeTableau10],["brbg",Pl(e.schemeBrBG,e.interpolateBrBG)],["prgn",Pl(e.schemePRGn,e.interpolatePRGn)],["piyg",Pl(e.schemePiYG,e.interpolatePiYG)],["puor",Pl(e.schemePuOr,e.interpolatePuOr)],["rdbu",Pl(e.schemeRdBu,e.interpolateRdBu)],["rdgy",Pl(e.schemeRdGy,e.interpolateRdGy)],["rdylbu",Pl(e.schemeRdYlBu,e.interpolateRdYlBu)],["rdylgn",Pl(e.schemeRdYlGn,e.interpolateRdYlGn)],["spectral",Pl(e.schemeSpectral,e.interpolateSpectral)],["burd",Tl(e.schemeRdBu,e.interpolateRdBu)],["buylrd",Tl(e.schemeRdYlBu,e.interpolateRdYlBu)],["blues",Ml(e.schemeBlues,e.interpolateBlues)],["greens",Ml(e.schemeGreens,e.interpolateGreens)],["greys",Ml(e.schemeGreys,e.interpolateGreys)],["oranges",Ml(e.schemeOranges,e.interpolateOranges)],["purples",Ml(e.schemePurples,e.interpolatePurples)],["reds",Ml(e.schemeReds,e.interpolateReds)],["turbo",$l(e.interpolateTurbo)],["viridis",$l(e.interpolateViridis)],["magma",$l(e.interpolateMagma)],["inferno",$l(e.interpolateInferno)],["plasma",$l(e.interpolatePlasma)],["cividis",$l(e.interpolateCividis)],["cubehelix",$l(e.interpolateCubehelixDefault)],["warm",$l(e.interpolateWarm)],["cool",$l(e.interpolateCool)],["bugn",Ml(e.schemeBuGn,e.interpolateBuGn)],["bupu",Ml(e.schemeBuPu,e.interpolateBuPu)],["gnbu",Ml(e.schemeGnBu,e.interpolateGnBu)],["orrd",Ml(e.schemeOrRd,e.interpolateOrRd)],["pubu",Ml(e.schemePuBu,e.interpolatePuBu)],["pubugn",Ml(e.schemePuBuGn,e.interpolatePuBuGn)],["purd",Ml(e.schemePuRd,e.interpolatePuRd)],["rdpu",Ml(e.schemeRdPu,e.interpolateRdPu)],["ylgn",Ml(e.schemeYlGn,e.interpolateYlGn)],["ylgnbu",Ml(e.schemeYlGnBu,e.interpolateYlGnBu)],["ylorbr",Ml(e.schemeYlOrBr,e.interpolateYlOrBr)],["ylorrd",Ml(e.schemeYlOrRd,e.interpolateYlOrRd)],["rainbow",kl(e.interpolateRainbow)],["sinebow",kl(e.interpolateSinebow)]]);function Ml(t,n){return({length:r})=>1===r?[t[3][1]]:2===r?[t[3][1],t[3][2]]:(r=Math.max(3,Math.floor(r)))>9?e.quantize(n,r):t[r]}function Pl(t,n){return({length:r})=>2===r?[t[3][0],t[3][2]]:(r=Math.max(3,Math.floor(r)))>11?e.quantize(n,r):t[r]}function Tl(t,n){return({length:r})=>2===r?[t[3][2],t[3][0]]:(r=Math.max(3,Math.floor(r)))>11?e.quantize((t=>n(1-t)),r):t[r].slice().reverse()}function $l(t){return({length:n})=>e.quantize(t,Math.max(2,Math.floor(n)))}function kl(t){return({length:n})=>e.quantize(t,Math.floor(n)+1).slice(0,-1)}function El(t){const e=`${t}`.toLowerCase();if(!jl.has(e))throw new Error(`unknown ordinal scheme: ${e}`);return jl.get(e)}function xl(t,e){const n=El(t),r="function"==typeof n?n({length:e}):n;return r.length!==e?r.slice(0,e):r}const Rl=new Map([["brbg",e.interpolateBrBG],["prgn",e.interpolatePRGn],["piyg",e.interpolatePiYG],["puor",e.interpolatePuOr],["rdbu",e.interpolateRdBu],["rdgy",e.interpolateRdGy],["rdylbu",e.interpolateRdYlBu],["rdylgn",e.interpolateRdYlGn],["spectral",e.interpolateSpectral],["burd",t=>e.interpolateRdBu(1-t)],["buylrd",t=>e.interpolateRdYlBu(1-t)],["blues",e.interpolateBlues],["greens",e.interpolateGreens],["greys",e.interpolateGreys],["purples",e.interpolatePurples],["reds",e.interpolateReds],["oranges",e.interpolateOranges],["turbo",e.interpolateTurbo],["viridis",e.interpolateViridis],["magma",e.interpolateMagma],["inferno",e.interpolateInferno],["plasma",e.interpolatePlasma],["cividis",e.interpolateCividis],["cubehelix",e.interpolateCubehelixDefault],["warm",e.interpolateWarm],["cool",e.interpolateCool],["bugn",e.interpolateBuGn],["bupu",e.interpolateBuPu],["gnbu",e.interpolateGnBu],["orrd",e.interpolateOrRd],["pubugn",e.interpolatePuBuGn],["pubu",e.interpolatePuBu],["purd",e.interpolatePuRd],["rdpu",e.interpolateRdPu],["ylgnbu",e.interpolateYlGnBu],["ylgn",e.interpolateYlGn],["ylorbr",e.interpolateYlOrBr],["ylorrd",e.interpolateYlOrRd],["rainbow",e.interpolateRainbow],["sinebow",e.interpolateSinebow]]);function Cl(t){const e=`${t}`.toLowerCase();if(!Rl.has(e))throw new Error(`unknown quantitative scheme: ${e}`);return Rl.get(e)}const Nl=new Set(["brbg","prgn","piyg","puor","rdbu","rdgy","rdylbu","rdylgn","spectral","burd","buylrd"]);function Bl(t){return null!=t&&Nl.has(`${t}`.toLowerCase())}const ql=t=>e=>t(1-e),Dl=[0,1],Al=new Map([["number",e.interpolateNumber],["rgb",e.interpolateRgb],["hsl",e.interpolateHsl],["hcl",e.interpolateHcl],["lab",e.interpolateLab]]);function Il(t){const e=`${t}`.toLowerCase();if(!Al.has(e))throw new Error(`unknown interpolator: ${e}`);return Al.get(e)}function Gl(t,n,r,{type:o,nice:i,clamp:a,zero:u,domain:c=Yl(t,r),unknown:s,round:l,scheme:f,interval:p,range:d=(cl.get(t)===ol?Ul(r,c):cl.get(t)===il?Wl(r,c):cl.get(t)===al?Dl:void 0),interpolate:h=(cl.get(t)===rl?null==f&&void 0!==d?e.interpolateRgb:Cl(void 0!==f?f:"cyclical"===o?"rainbow":"turbo"):l?e.interpolateRound:e.interpolateNumber),reverse:m}){if(p=Js(p,o),"cyclical"!==o&&"sequential"!==o||(o="linear"),m=!!m,"function"!=typeof h&&(h=Il(h)),1===h.length?(m&&(h=ql(h),m=!1),void 0===d&&2===(d=Float64Array.from(c,((t,e)=>e/(c.length-1)))).length&&(d=Dl),n.interpolate((d===Dl?As:Jl)(h))):n.interpolate(h),u){const[t,n]=e.extent(c);(t>0||n<0)&&(c=function(t,e=Array){return t instanceof e?t.slice():e.from(t)}(c),el(c)!==Math.sign(t)?c[c.length-1]=0:c[0]=0)}return m&&(c=e.reverse(c)),n.domain(c).unknown(s),i&&(n.nice(function(t,e){return!0===t?void 0:"number"==typeof t?t:function(t,e){if((t=Js(t,e))&&"function"!=typeof t.ceil)throw new Error("invalid interval: missing ceil method");return t}(t,e)}(i,o)),c=n.domain()),void 0!==d&&n.range(d),a&&n.clamp(a),{type:o,domain:c,range:d,scale:n,interpolate:h,interval:p}}function Ll(t,n,{exponent:r=1,...o}){return Gl(t,e.scalePow().exponent(r),n,{...o,type:"pow"})}function zl(t,n,{domain:r=[0],unknown:o,scheme:i="rdylbu",interpolate:a,range:u=(void 0!==a?e.quantize(a,r.length+1):cl.get(t)===rl?xl(i,r.length+1):void 0),reverse:c}){const s=el(r=_s(r));if(!isNaN(s)&&!function(t,n){for(let r=1,o=t.length,i=t[0];rvoid 0===t?t:e.min(t,n))),e.max(t,(({value:t})=>void 0===t?t:e.max(t,n)))]:[0,1]}function Yl(t,e){const n=cl.get(t);return(n===ol||n===al||n===il?_l:Fl)(e)}function _l(t){return[0,t.length?e.max(t,(({value:t})=>void 0===t?t:e.max(t,js))):1]}function Ul(t,n){const r=t.find((({radius:t})=>void 0!==t));if(void 0!==r)return[0,r.radius];const o=e.quantile(t,.5,(({value:t})=>void 0===t?NaN:e.quantile(t,.25,Ms))),i=n.map((t=>3*Math.sqrt(t/o))),a=30/e.max(i);return a<1?i.map((t=>t*a)):i}function Wl(t,n){const r=e.median(t,(({value:t})=>void 0===t?NaN:e.median(t,Math.abs))),o=n.map((t=>12*t/r)),i=60/e.max(o);return i<1?o.map((t=>t*i)):o}function Hl(t){for(const{value:e}of t)if(void 0!==e)for(let n of e){if(n>0)return Fl(t,Ms);if(n<0)return Fl(t,Ps)}return[1,10]}function Vl(t){const e=[];for(const{value:n}of t)if(void 0!==n)for(const t of n)e.push(t);return e}function Jl(t){return(e,n)=>r=>t(e+r*(n-e))}function Kl(t,n,r,o,{type:i,nice:a,clamp:u,domain:c=Fl(o),unknown:s,pivot:l=0,scheme:f,range:p,symmetric:d=!0,interpolate:h=(cl.get(t)===rl?null==f&&void 0!==p?e.interpolateRgb:Cl(void 0!==f?f:"rdbu"):e.interpolateNumber),reverse:m}){l=+l;let[g,y]=c;if(e.descending(g,y)<0&&([g,y]=[y,g],m=!m),g=Math.min(g,l),y=Math.max(y,l),"function"!=typeof h&&(h=Il(h)),void 0!==p&&(h=1===h.length?Jl(h)(...p):e.piecewise(h,p)),m&&(h=ql(h)),d){const t=r.apply(l),e=t-r.apply(g),n=r.apply(y)-t;en&&(y=r.invert(t+e))}return n.domain([g,l,y]).unknown(s).interpolator(h),u&&n.clamp(u),a&&n.nice(a),{type:i,domain:[g,y],pivot:l,interpolate:h,scale:n}}function Xl(t,n,{exponent:r=1,...o}){return Kl(t,e.scaleDivergingPow().exponent(r=+r),function(t){return.5===t?ef:{apply:e=>Math.sign(e)*Math.pow(Math.abs(e),t),invert:e=>Math.sign(e)*Math.pow(Math.abs(e),1/t)}}(r),n,{...o,type:"diverging-pow"})}function Zl(t,n,{constant:r=1,...o}){return Kl(t,e.scaleDivergingSymlog().constant(r=+r),function(t){return{apply:e=>Math.sign(e)*Math.log1p(Math.abs(e/t)),invert:e=>Math.sign(e)*Math.expm1(Math.abs(e))*t}}(r),n,o)}const Ql={apply:t=>t,invert:t=>t},tf={apply:Math.log,invert:Math.exp},ef={apply:t=>Math.sign(t)*Math.sqrt(Math.abs(t)),invert:t=>Math.sign(t)*(t*t)};function nf(t,e,n,r){return Gl(t,e,n,r)}const rf=Symbol("ordinal");function of(t,n,r,{type:o,interval:i,domain:a,range:u,reverse:c,hint:s}){return i=Js(i,o),void 0===a&&(a=cf(r,i,t)),"categorical"!==o&&o!==rf||(o="ordinal"),c&&(a=e.reverse(a)),n.domain(a),void 0!==u&&("function"==typeof u&&(u=u(a)),n.range(u)),{type:o,domain:a,range:u,scale:n,hint:s,interval:i}}function af(t,n,{type:r,interval:o,domain:i,range:a,scheme:u,unknown:c,...s}){let l;if(o=Js(o,r),void 0===i&&(i=cf(n,o,t)),cl.get(t)===ul)l=function(t){return{fill:sf(t,"fill"),stroke:sf(t,"stroke")}}(n),a=void 0===a?function(t){return tl(t.fill)?e.symbolsStroke:e.symbolsFill}(l):Us(a,pl);else if(cl.get(t)===rl&&(void 0!==a||"ordinal"!==r&&r!==rf||(a=function(t,e="greys"){const n=new Set,[r,o]=xl(e,2);for(const e of t)if(null!=e)if(!0===e)n.add(o);else{if(!1!==e)return;n.add(r)}return[...n]}(i,u),void 0!==a&&(u=void 0)),void 0===u&&void 0===a&&(u="ordinal"===r?"turbo":"tableau10"),void 0!==u))if(void 0!==a){const t=Cl(u),n=a[0],r=a[1]-a[0];a=({length:o})=>e.quantize((e=>t(n+r*e)),o)}else a=El(u);if(c===e.scaleImplicit)throw new Error(`implicit unknown on ${t} scale is not supported`);return of(t,e.scaleOrdinal().unknown(c),n,{...s,type:r,domain:i,range:a,hint:l})}function uf(t,e,n,r){let{round:o}=n;return void 0!==o&&t.round(o=!!o),(t=of(r,t,e,n)).round=o,t}function cf(t,n,r){const o=new e.InternSet;for(const{value:e,domain:n}of t){if(void 0!==n)return n();if(void 0!==e)for(const t of e)o.add(t)}if(void 0!==n){const[t,r]=e.extent(o).map(n.floor,n);return n.range(t,n.offset(r))}if(o.size>1e4&&cl.get(r)===nl)throw new Error(`implicit ordinal domain of ${r} scale has more than 10,000 values`);return e.sort(o,Os)}function sf(t,e){let n;for(const{hint:r}of t){const t=r?.[e];if(void 0!==t)if(void 0===n)n=t;else if(n!==t)return}return n}function lf(t,n,r){return function(t,n=[],r={}){const o=function(t,e,{type:n,domain:r,range:o,scheme:i,pivot:a,projection:u}){if("fx"===t||"fy"===t)return"band";"x"!==t&&"y"!==t||null==u||(n=pf);for(const{type:t}of e)if(void 0!==t)if(void 0===n)n=t;else if(n!==t)throw new Error(`scale incompatible with channel: ${n} !== ${t}`);if(n===pf)return;if(void 0!==n)return n;if(void 0===r&&!e.some((({value:t})=>void 0!==t)))return;const c=cl.get(t);if(c===ol)return"sqrt";if(c===al||c===il)return"linear";if(c===ul)return"ordinal";if((r||o||[]).length>2)return df(c);if(void 0!==r)return Ks(r)?df(c):Xs(r)?"utc":c!==rl||null==a&&!Bl(i)?"linear":"diverging";const s=e.map((({value:t})=>t)).filter((t=>void 0!==t));return s.some(Ks)?df(c):s.some(Xs)?"utc":c!==rl||null==a&&!Bl(i)?"linear":"diverging"}(t,n,r);if(void 0===r.type&&void 0===r.domain&&void 0===r.range&&null==r.interval&&"fx"!==t&&"fy"!==t&&hf({type:o})){const e=n.map((({value:t})=>t)).filter((t=>void 0!==t));e.some(Xs)?dl(`Warning: some data associated with the ${t} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${ff(o)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${t} scale to "${ff(o)}".`):e.some(Zs)?dl(`Warning: some data associated with the ${t} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${ff(o)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${t} scale to "${ff(o)}".`):e.some(Qs)&&dl(`Warning: some data associated with the ${t} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${ff(o)}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${t} scale to "${ff(o)}".`)}switch(r.type=o,o){case"diverging":case"diverging-sqrt":case"diverging-pow":case"diverging-log":case"diverging-symlog":case"cyclical":case"sequential":case"linear":case"sqrt":case"threshold":case"quantile":case"pow":case"log":case"symlog":r=mf(n,r,Is);break;case"identity":switch(cl.get(t)){case nl:r=mf(n,r,Is);break;case ul:r=mf(n,r,gf)}break;case"utc":case"time":r=mf(n,r,Ls)}switch(o){case"diverging":return function(t,n,r){return Kl(t,e.scaleDiverging(),Ql,n,r)}(t,n,r);case"diverging-sqrt":return function(t,e,n){return Xl(t,e,{...n,exponent:.5})}(t,n,r);case"diverging-pow":return Xl(t,n,r);case"diverging-log":return function(t,n,{base:r=10,pivot:o=1,domain:i=Fl(n,o<0?Ps:Ms),...a}){return Kl(t,e.scaleDivergingLog().base(r=+r),tf,n,{domain:i,pivot:o,...a})}(t,n,r);case"diverging-symlog":return Zl(t,n,r);case"categorical":case"ordinal":case rf:return af(t,n,r);case"cyclical":case"sequential":case"linear":return function(t,n,r){return Gl(t,e.scaleLinear(),n,r)}(t,n,r);case"sqrt":return function(t,e,n){return Ll(t,e,{...n,exponent:.5})}(t,n,r);case"threshold":return zl(t,0,r);case"quantile":return function(t,n,{range:r,quantiles:o=(void 0===r?5:(r=[...r]).length),n:i=o,scheme:a="rdylbu",domain:u=Vl(n),unknown:c,interpolate:s,reverse:l}){return void 0===r&&(r=void 0!==s?e.quantize(s,i):cl.get(t)===rl?xl(a,i):void 0),u.length>0&&(u=e.scaleQuantile(u,void 0===r?{length:i}:r).quantiles()),zl(t,0,{domain:u,range:r,reverse:l,unknown:c})}(t,n,r);case"quantize":return function(t,n,{range:r,n:o=(void 0===r?5:(r=[...r]).length),scheme:i="rdylbu",domain:a=Yl(t,n),unknown:u,interpolate:c,reverse:s}){const[l,f]=e.extent(a);let p;return void 0===r?(p=e.ticks(l,f,o),p[0]<=l&&p.splice(0,1),p[p.length-1]>=f&&p.pop(),o=p.length+1,r=void 0!==c?e.quantize(c,o):cl.get(t)===rl?xl(i,o):void 0):(p=e.quantize(e.interpolateNumber(l,f),o+1).slice(1,-1),l instanceof Date&&(p=p.map((t=>new Date(t))))),el(_s(a))<0&&p.reverse(),zl(t,0,{domain:p,range:r,reverse:s,unknown:u})}(t,n,r);case"pow":return Ll(t,n,r);case"log":return function(t,n,{base:r=10,domain:o=Hl(n),...i}){return Gl(t,e.scaleLog().base(r),n,{...i,domain:o})}(t,n,r);case"symlog":return function(t,n,{constant:r=1,...o}){return Gl(t,e.scaleSymlog().constant(r),n,o)}(t,n,r);case"utc":return function(t,n,r){return nf(t,e.scaleUtc(),n,r)}(t,n,r);case"time":return function(t,n,r){return nf(t,e.scaleTime(),n,r)}(t,n,r);case"point":return function(t,n,{align:r=.5,padding:o=.5,...i}){return uf(e.scalePoint().align(r).padding(o),n,i,t)}(t,n,r);case"band":return function(t,n,{align:r=.5,padding:o=.1,paddingInner:i=o,paddingOuter:a=("fx"===t||"fy"===t?0:o),...u}){return uf(e.scaleBand().align(r).paddingInner(i).paddingOuter(a),n,u,t)}(t,n,r);case"identity":return cl.get(t)===nl?{type:"identity",scale:e.scaleIdentity()}:{type:"identity"};case void 0:return;default:throw new Error(`unknown scale type: ${o}`)}}(t,void 0===r?void 0:[{hint:r}],{...n})}function ff(t){return"symbol"==typeof t?t.description:t}const pf={toString:()=>"projection"};function df(t){switch(t){case nl:return"point";case rl:return rf;default:return"ordinal"}}function hf({type:t}){return"ordinal"===t||"point"===t||"band"===t||t===rf}function mf(t,{domain:e,...n},r){for(const e of t)void 0!==e.value&&(e.value=r(e.value));return{domain:void 0===e?e:r(e),...n}}function gf(t){return Us(t,pl)}const yf=function(t){let e,n;return(...r)=>((n?.length!==r.length||n.some(((t,e)=>t!==r[e])))&&(n=r,e=t(...r)),e)}((t=>new Intl.NumberFormat(t)));function vf(t){return Ts(t,"Invalid Date")}function bf(t,e){if((t=Ds(t))!==e)return t}!function(t="en-US"){const e=function(t="en-US"){const e=yf(t);return t=>null==t||isNaN(t)?void 0:e.format(t)}(t)}();const wf=/^-?([_a-z]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])([_a-z0-9-]|[\240-\377]|\\[0-9a-f]{1,6}(\r\n|[ \t\r\n\f])?|\\[^\r\n\f0-9a-f])*$/i;function Sf(t){if(void 0===t)return"plot-d6a7b5";if(t=`${t}`,!wf.test(t))throw new Error(`invalid class name: ${t}`);return t}function Of(t,e){if("string"==typeof e)t.property("style",e);else if(null!=e)for(const n of t)Object.assign(n.style,e)}function jf(t){return hf(t)&&void 0===t.interval?void 0:"tabular-nums"}function Mf(t,e){if(null==e)return e;const n=t(e);if(!n)throw new Error(`scale not found: ${e}`);return n}function Pf(t,n={},r){let{columns:o,tickFormat:i,fontVariant:a=jf(t),swatchSize:u=15,swatchWidth:c=u,swatchHeight:s=u,marginLeft:l=0,className:f,style:p,width:d}=n;const h=Sl(n);f=Sf(f),i=function(t,n){return void 0===t?Xs(n)?vf:Ds:"function"==typeof t?t:("string"==typeof t?Xs(n)?e.utcFormat:e.format:As)(t)}(i,t.domain);const m=Ol("div",h).attr("class",`${f}-swatches ${f}-swatches-${null!=o?"columns":"wrap"}`);let g;return null!=o?(g=`.${f}-swatches-columns .${f}-swatch {\n display: flex;\n align-items: center;\n break-inside: avoid;\n padding-bottom: 1px;\n}\n.${f}-swatches-columns .${f}-swatch::before {\n flex-shrink: 0;\n}\n.${f}-swatches-columns .${f}-swatch-label {\n white-space: nowrap;\n overflow: hidden;\n text-overflow: ellipsis;\n}`,m.style("columns",o).selectAll().data(t.domain).enter().append("div").attr("class",`${f}-swatch`).call(r,t,c,s).call((t=>t.append("div").attr("class",`${f}-swatch-label`).attr("title",i).text(i)))):(g=`.${f}-swatches-wrap {\n display: flex;\n align-items: center;\n min-height: 33px;\n flex-wrap: wrap;\n}\n.${f}-swatches-wrap .${f}-swatch {\n display: inline-flex;\n align-items: center;\n margin-right: 1em;\n}`,m.selectAll().data(t.domain).enter().append("span").attr("class",`${f}-swatch`).call(r,t,c,s).append((function(){return this.ownerDocument.createTextNode(i.apply(this,arguments))}))),m.call((t=>t.insert("style","*").text(`.${f}-swatches {\n font-family: system-ui, sans-serif;\n font-size: 10px;\n margin-bottom: 0.5em;\n}\n.${f}-swatch > svg {\n margin-right: 0.5em;\n overflow: visible;\n}\n${g}`))).style("margin-left",l?+l+"px":null).style("width",void 0===d?null:+d+"px").style("font-variant",bf(a,"normal")).call(Of,p).node()}const Tf=new Map([["symbol",function(t,{fill:n=(void 0!==t.hint?.fill?t.hint.fill:"none"),fillOpacity:r=1,stroke:o=(void 0!==t.hint?.stroke?t.hint.stroke:tl(n)?"currentColor":"none"),strokeOpacity:i=1,strokeWidth:a=1.5,r:u=4.5,...c}={},s){const[l,f]=Fs(n),[p,d]=Fs(o),h=Mf(s,l),m=Mf(s,p),g=u*u*Math.PI;return r=Ys(r)[1],i=Ys(i)[1],a=Ys(a)[1],Pf(t,c,((n,o,u,c)=>n.append("svg").attr("viewBox","-8 -8 16 16").attr("width",u).attr("height",c).attr("fill","color"===l?t=>h.scale(t):f).attr("fill-opacity",r).attr("stroke","color"===p?t=>m.scale(t):d).attr("stroke-opacity",i).attr("stroke-width",a).append("path").attr("d",(n=>{const r=e.pathRound();return t.scale(n).draw(r,g),r}))))}],["color",kf],["opacity",function({type:t,interpolate:n,...r},{legend:o=!0,color:i=e.rgb(0,0,0),...a}){if(!n)throw new Error(`${t} opacity scales are not supported`);!0===o&&(o="ramp");if("ramp"!==`${o}`.toLowerCase())throw new Error(`${o} opacity legends are not supported`);return kf({type:t,...r,interpolate:Ef(i)},{legend:o,...a})}]]);function $f({className:t,...e},{label:n,ticks:r,tickFormat:o}={},i){return function(t={},...e){let n=t;for(const r of e)for(const e in r)if(void 0===n[e]){const o=r[e];n===t?n={...n,[e]:o}:n[e]=o}return n}(i,{className:t,...e},{label:n,ticks:r,tickFormat:o})}function kf(t,{legend:n=!0,...r}){if(!0===n&&(n="ordinal"===t.type?"swatches":"ramp"),void 0!==t.domain)switch(`${n}`.toLowerCase()){case"swatches":return function(t,{opacity:e,...n}={}){if(!hf(t)&&!function({type:t}){return"threshold"===t}(t))throw new Error(`swatches legend requires ordinal or threshold color scale (not ${t.type})`);return Pf(t,n,((t,n,r,o)=>t.append("svg").attr("width",r).attr("height",o).attr("fill",n.scale).attr("fill-opacity",Ys(e)[1]).append("rect").attr("width","100%").attr("height","100%")))}(t,r);case"ramp":return function(t,n){let{label:r=t.label,tickSize:o=6,width:i=240,height:a=44+o,marginTop:u=18,marginRight:c=0,marginBottom:s=16+o,marginLeft:l=0,style:f,ticks:p=(i-l-c)/64,tickFormat:d,fontVariant:h=jf(t),round:m=!0,opacity:g,className:y}=n;const v=Sl(n);y=Sf(y),g=Ys(g)[1],null===d&&(d=()=>null);const b=Ol("svg",v).attr("class",`${y}-ramp`).attr("font-family","system-ui, sans-serif").attr("font-size",10).attr("width",i).attr("height",a).attr("viewBox",`0 0 ${i} ${a}`).call((t=>t.append("style").text(`.${y}-ramp {\n display: block;\n background: white;\n height: auto;\n height: intrinsic;\n max-width: 100%;\n overflow: visible;\n}\n.${y}-ramp text {\n white-space: pre;\n}`))).call(Of,f);let w,S=t=>t.selectAll(".tick line").attr("y1",u+s-a);const O=m?(t,e)=>t.rangeRound(e):(t,e)=>t.range(e),{type:j,domain:M,range:P,interpolate:T,scale:$,pivot:k}=t;if(T){const t=void 0===P?T:e.piecewise(1===T.length?Jl(T):T,P);w=O($.copy(),e.quantize(e.interpolateNumber(l,i-c),Math.min(M.length+(void 0!==k),void 0===P?1/0:P.length)));const n=256,r=v.document.createElement("canvas");r.width=n,r.height=1;const o=r.getContext("2d");for(let e=0,r=n-1;et:"string"==typeof d?e.format(d):d;w=O(e.scaleLinear().domain([-1,P.length-1]),[l,i-c]),b.append("g").attr("fill-opacity",g).selectAll().data(P).enter().append("rect").attr("x",((t,e)=>w(e-1))).attr("y",u).attr("width",((t,e)=>w(e)-w(e-1))).attr("height",a-u-s).attr("fill",(t=>t)),p=Us(t,((t,e)=>e)),d=e=>n(t[e],e)}else w=O(e.scaleBand().domain(M),[l,i-c]),b.append("g").attr("fill-opacity",g).selectAll().data(M).enter().append("rect").attr("x",w).attr("y",u).attr("width",Math.max(0,w.bandwidth()-1)).attr("height",a-u-s).attr("fill",$),S=()=>{};return b.append("g").attr("transform",`translate(0,${a-s})`).call(e.axisBottom(w).ticks(Array.isArray(p)?null:p,"string"==typeof d?d:void 0).tickFormat("function"==typeof d?d:void 0).tickSize(o).tickValues(Array.isArray(p)?p:null)).attr("font-size",null).attr("font-family",null).attr("font-variant",bf(h,"normal")).call(S).call((t=>t.select(".domain").remove())),void 0!==r&&b.append("text").attr("x",l).attr("y",u-6).attr("fill","currentColor").attr("font-weight","bold").text(r),b.node()}(t,r);default:throw new Error(`unknown legend type: ${n}`)}}function Ef(t){const{r:n,g:r,b:o}=e.rgb(t)||e.rgb(0,0,0);return t=>`rgba(${n},${r},${o},${t})`}var xf="#ch-plugin-legend",Rf={enabled:!0,itemSelector:null,label:null,width:130},Cf=function(){function e(t){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,e),this.name="Legend",this.calendar=t,this.root=null,this.shown=!1,this.options=Rf}var r,o,i;return r=e,o=[{key:"setup",value:function(t){this.options=Object.assign(Object.assign({},Rf),t)}},{key:"paint",value:function(){var e=this.calendar.options.options.scale,n=this.options,r=n.enabled,o=n.itemSelector;if(!r||o&&t.select(o).empty())return this.destroy();this.shown=!0,this.root=t.select(o||this.calendar.options.options.itemSelector),this.root.select(xf).empty()?this.root=this.root.append("div").attr("id",xf.slice(1)):this.root=this.root.select(xf);var i=function(t={}){for(const[e,n]of Tf){const r=t[e];if(Hs(r)){const o=Sl(t);let i;if("symbol"===e){const{fill:e,stroke:n=(void 0===e&&Hs(t.color)?"color":void 0)}=t;i={fill:e,stroke:n}}return n(lf(e,r,i),$f(o,r,t),(e=>Hs(t[e])?lf(e,t[e]):null))}}throw new Error("unknown legend type; no scale found")}(Object.assign(Object.assign({},e),this.options));return this.root.selectAll("*").remove(),this.root.append((function(){return i})),Promise.resolve()}},{key:"destroy",value:function(){return null!==this.root&&(this.root.remove(),this.root=null),Promise.resolve()}}],o&&n(r.prototype,o),i&&n(r,i),Object.defineProperty(r,"prototype",{writable:!1}),e}();return Cf}));//# sourceMappingURL=Legend.min.js.map diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.js.map b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.js.map new file mode 100644 index 0000000..2dc6637 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Legend.min.js.map @@ -0,0 +1 @@ +{"version":3,"file":"Legend.min.js","sources":["../../node_modules/core-js/internals/fails.js","../../node_modules/core-js/internals/descriptors.js","../../node_modules/core-js/internals/function-bind-native.js","../../node_modules/core-js/internals/function-uncurry-this.js","../../node_modules/core-js/internals/is-null-or-undefined.js","../../node_modules/core-js/internals/require-object-coercible.js","../../node_modules/core-js/internals/to-object.js","../../node_modules/core-js/internals/has-own-property.js","../../node_modules/core-js/internals/function-name.js","../../node_modules/core-js/internals/document-all.js","../../node_modules/core-js/internals/is-callable.js","../../node_modules/core-js/internals/global.js","../../node_modules/core-js/internals/define-global-property.js","../../node_modules/core-js/internals/shared-store.js","../../node_modules/core-js/internals/inspect-source.js","../../node_modules/core-js/internals/engine-v8-version.js","../../node_modules/core-js/internals/weak-map-basic-detection.js","../../node_modules/core-js/internals/is-object.js","../../node_modules/core-js/internals/document-create-element.js","../../node_modules/core-js/internals/ie8-dom-define.js","../../node_modules/core-js/internals/v8-prototype-define-bug.js","../../node_modules/core-js/internals/an-object.js","../../node_modules/core-js/internals/function-call.js","../../node_modules/core-js/internals/get-built-in.js","../../node_modules/core-js/internals/object-is-prototype-of.js","../../node_modules/core-js/internals/engine-user-agent.js","../../node_modules/core-js/internals/symbol-constructor-detection.js","../../node_modules/core-js/internals/use-symbol-as-uid.js","../../node_modules/core-js/internals/is-symbol.js","../../node_modules/core-js/internals/try-to-string.js","../../node_modules/core-js/internals/a-callable.js","../../node_modules/core-js/internals/get-method.js","../../node_modules/core-js/internals/ordinary-to-primitive.js","../../node_modules/core-js/internals/shared.js","../../node_modules/core-js/internals/uid.js","../../node_modules/core-js/internals/well-known-symbol.js","../../node_modules/core-js/internals/to-primitive.js","../../node_modules/core-js/internals/to-property-key.js","../../node_modules/core-js/internals/object-define-property.js","../../node_modules/core-js/internals/create-property-descriptor.js","../../node_modules/core-js/internals/internal-state.js","../../node_modules/core-js/internals/create-non-enumerable-property.js","../../node_modules/core-js/internals/shared-key.js","../../node_modules/core-js/internals/hidden-keys.js","../../node_modules/core-js/internals/make-built-in.js","../../node_modules/core-js/internals/define-built-in-accessor.js","../../node_modules/core-js/modules/es.function.name.js","../../node_modules/core-js/internals/object-property-is-enumerable.js","../../node_modules/core-js/internals/classof-raw.js","../../node_modules/core-js/internals/indexed-object.js","../../node_modules/core-js/internals/to-indexed-object.js","../../node_modules/core-js/internals/object-get-own-property-descriptor.js","../../node_modules/core-js/internals/define-built-in.js","../../node_modules/core-js/internals/math-trunc.js","../../node_modules/core-js/internals/to-integer-or-infinity.js","../../node_modules/core-js/internals/to-absolute-index.js","../../node_modules/core-js/internals/to-length.js","../../node_modules/core-js/internals/length-of-array-like.js","../../node_modules/core-js/internals/array-includes.js","../../node_modules/core-js/internals/object-keys-internal.js","../../node_modules/core-js/internals/enum-bug-keys.js","../../node_modules/core-js/internals/object-get-own-property-names.js","../../node_modules/core-js/internals/object-get-own-property-symbols.js","../../node_modules/core-js/internals/own-keys.js","../../node_modules/core-js/internals/copy-constructor-properties.js","../../node_modules/core-js/internals/is-forced.js","../../node_modules/core-js/internals/export.js","../../node_modules/core-js/internals/object-keys.js","../../node_modules/core-js/internals/object-assign.js","../../node_modules/core-js/modules/es.object.assign.js","../../node_modules/core-js/internals/to-string-tag-support.js","../../node_modules/core-js/internals/classof.js","../../node_modules/core-js/internals/object-to-string.js","../../node_modules/core-js/modules/es.object.to-string.js","../../node_modules/core-js/internals/engine-is-node.js","../../node_modules/core-js/internals/function-uncurry-this-accessor.js","../../node_modules/core-js/internals/a-possible-prototype.js","../../node_modules/core-js/internals/object-set-prototype-of.js","../../node_modules/core-js/internals/set-to-string-tag.js","../../node_modules/core-js/internals/set-species.js","../../node_modules/core-js/internals/an-instance.js","../../node_modules/core-js/internals/is-constructor.js","../../node_modules/core-js/internals/task.js","../../node_modules/core-js/internals/a-constructor.js","../../node_modules/core-js/internals/species-constructor.js","../../node_modules/core-js/internals/function-apply.js","../../node_modules/core-js/internals/function-uncurry-this-clause.js","../../node_modules/core-js/internals/function-bind-context.js","../../node_modules/core-js/internals/html.js","../../node_modules/core-js/internals/array-slice.js","../../node_modules/core-js/internals/validate-arguments-length.js","../../node_modules/core-js/internals/engine-is-ios.js","../../node_modules/core-js/internals/queue.js","../../node_modules/core-js/internals/microtask.js","../../node_modules/core-js/internals/engine-is-ios-pebble.js","../../node_modules/core-js/internals/engine-is-webos-webkit.js","../../node_modules/core-js/internals/perform.js","../../node_modules/core-js/internals/promise-native-constructor.js","../../node_modules/core-js/internals/engine-is-deno.js","../../node_modules/core-js/internals/engine-is-browser.js","../../node_modules/core-js/internals/promise-constructor-detection.js","../../node_modules/core-js/internals/new-promise-capability.js","../../node_modules/core-js/modules/es.promise.constructor.js","../../node_modules/core-js/internals/host-report-errors.js","../../node_modules/core-js/internals/iterators.js","../../node_modules/core-js/internals/is-array-iterator-method.js","../../node_modules/core-js/internals/get-iterator-method.js","../../node_modules/core-js/internals/get-iterator.js","../../node_modules/core-js/internals/iterator-close.js","../../node_modules/core-js/internals/iterate.js","../../node_modules/core-js/internals/check-correctness-of-iteration.js","../../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","../../node_modules/core-js/modules/es.promise.all.js","../../node_modules/core-js/modules/es.promise.catch.js","../../node_modules/core-js/modules/es.promise.race.js","../../node_modules/core-js/modules/es.promise.reject.js","../../node_modules/core-js/internals/promise-resolve.js","../../node_modules/core-js/modules/es.promise.resolve.js","../../node_modules/@observablehq/plot/src/defined.js","../../node_modules/isoformat/src/format.js","../../node_modules/isoformat/src/parse.js","../../node_modules/@observablehq/plot/src/time.js","../../node_modules/@observablehq/plot/src/options.js","../../node_modules/@observablehq/plot/src/scales/index.js","../../node_modules/@observablehq/plot/src/symbol.js","../../node_modules/@observablehq/plot/src/warnings.js","../../node_modules/@observablehq/plot/src/projection.js","../../node_modules/@observablehq/plot/src/context.js","../../node_modules/@observablehq/plot/src/scales/schemes.js","../../node_modules/@observablehq/plot/src/scales/quantitative.js","../../node_modules/@observablehq/plot/src/scales/diverging.js","../../node_modules/@observablehq/plot/src/scales/temporal.js","../../node_modules/@observablehq/plot/src/scales/ordinal.js","../../node_modules/@observablehq/plot/src/scales.js","../../node_modules/@observablehq/plot/src/format.js","../../node_modules/@observablehq/plot/src/memoize.js","../../node_modules/@observablehq/plot/src/style.js","../../node_modules/@observablehq/plot/src/axes.js","../../node_modules/@observablehq/plot/src/legends/swatches.js","../../node_modules/@observablehq/plot/src/legends.js","../../node_modules/@observablehq/plot/src/legends/ramp.js","../../../src/plugins/Legend.ts"],"sourcesContent":["'use strict';\nmodule.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-function-prototype-bind -- safe\n var test = (function () { /* empty */ }).bind();\n // eslint-disable-next-line no-prototype-builtins -- safe\n return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n return function () {\n return call.apply(fn, arguments);\n };\n};\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n return it === null || it === undefined;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n return it;\n};\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar documentAll = typeof document == 'object' && document.all;\n\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nvar IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;\n\nmodule.exports = {\n all: documentAll,\n IS_HTMLDDA: IS_HTMLDDA\n};\n","'use strict';\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = $documentAll.IS_HTMLDDA ? function (argument) {\n return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n return typeof argument == 'function';\n};\n","'use strict';\nvar check = function (it) {\n return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n check(typeof this == 'object' && this) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\nmodule.exports = $documentAll.IS_HTMLDDA ? function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;\n} : function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a !== 7;\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype !== 42;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol('symbol detection');\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n // of course, fail.\n return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n try {\n return $String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.34.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',\n license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',\n source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name)) {\n WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n ? Symbol[name]\n : createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw new $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","'use strict';\nmodule.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n /* eslint-disable no-self-assign -- prototype methods protection */\n store.get = store.get;\n store.has = store.has;\n store.set = store.set;\n /* eslint-enable no-self-assign -- prototype methods protection */\n set = function (it, metadata) {\n if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n store.set(it, metadata);\n return metadata;\n };\n get = function (it) {\n return store.get(it) || {};\n };\n has = function (it) {\n return store.has(it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (options && options.getter) name = 'get ' + name;\n if (options && options.setter) name = 'set ' + name;\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n else value.name = name;\n }\n if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n defineProperty(value, 'length', { value: options.arity });\n }\n try {\n if (options && hasOwn(options, 'constructor') && options.constructor) {\n if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n } else if (value.prototype) value.prototype = undefined;\n } catch (error) { /* empty */ }\n var state = enforceInternalState(value);\n if (!hasOwn(state, 'source')) {\n state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineProperty = require('../internals/object-define-property');\n\nmodule.exports = function (target, name, descriptor) {\n if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });\n if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });\n return defineProperty.f(target, name, descriptor);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar FUNCTION_NAME_EXISTS = require('../internals/function-name').EXISTS;\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\n\nvar FunctionPrototype = Function.prototype;\nvar functionToString = uncurryThis(FunctionPrototype.toString);\nvar nameRE = /function\\b(?:\\s|\\/\\*[\\S\\s]*?\\*\\/|\\/\\/[^\\n\\r]*[\\n\\r]+)*([^\\s(/]*)/;\nvar regExpExec = uncurryThis(nameRE.exec);\nvar NAME = 'name';\n\n// Function instances `.name` property\n// https://tc39.es/ecma262/#sec-function-instances-name\nif (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {\n defineBuiltInAccessor(FunctionPrototype, NAME, {\n configurable: true,\n get: function () {\n try {\n return regExpExec(nameRE, functionToString(this))[1];\n } catch (error) {\n return '';\n }\n }\n });\n}\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- NaN check\n return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el !== el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value !== value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value === POLYFILL ? true\n : value === NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.dontCallGetSet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || defineGlobalProperty(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.dontCallGetSet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n defineBuiltIn(target, key, sourceProperty, options);\n }\n};\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol('assign detection');\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","'use strict';\nvar $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {\n assign: assign\n});\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar global = require('../internals/global');\nvar classof = require('../internals/classof-raw');\n\nmodule.exports = classof(global.process) === 'process';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nmodule.exports = function (object, key, method) {\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));\n } catch (error) { /* empty */ }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw new $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","'use strict';\n/* eslint-disable no-proto -- safe */\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (target, TAG, STATIC) {\n if (target && !STATIC) target = target.prototype;\n if (target && !hasOwn(target, TO_STRING_TAG)) {\n defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineBuiltInAccessor(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw new $TypeError('Incorrect invocation');\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.test(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n }\n try {\n // we can't check .prototype since constructors produced by .bind haven't it\n // `Function#toString` throws on some built-it function in some legacy engines\n // (for example, `DOMQuad` and similar in FF41-)\n return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n } catch (error) {\n return true;\n }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar $location, defer, channel, port;\n\nfails(function () {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n $location = global.location;\n});\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar eventListener = function (event) {\n run(event.data);\n};\n\nvar globalPostMessageDefer = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), $location.protocol + '//' + $location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(handler) {\n validateArgumentsLength(arguments.length, 1);\n var fn = isCallable(handler) ? handler : Function(handler);\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(fn, undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = eventListener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n $location && $location.protocol !== 'file:' &&\n !fails(globalPostMessageDefer)\n ) {\n defer = globalPostMessageDefer;\n global.addEventListener('message', eventListener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","'use strict';\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a constructor');\n};\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","'use strict';\nvar classofRaw = require('../internals/classof-raw');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (fn) {\n // Nashorn bug:\n // https://github.com/zloirock/core-js/issues/1128\n // https://github.com/zloirock/core-js/issues/1130\n if (classofRaw(fn) === 'Function') return uncurryThis(fn);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","'use strict';\nvar $TypeError = TypeError;\n\nmodule.exports = function (passed, required) {\n if (passed < required) throw new $TypeError('Not enough arguments');\n return passed;\n};\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line redos/no-vulnerable -- safe\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","'use strict';\nvar Queue = function () {\n this.head = null;\n this.tail = null;\n};\n\nQueue.prototype = {\n add: function (item) {\n var entry = { item: item, next: null };\n var tail = this.tail;\n if (tail) tail.next = entry;\n else this.head = entry;\n this.tail = entry;\n },\n get: function () {\n var entry = this.head;\n if (entry) {\n var next = this.head = entry.next;\n if (next === null) this.tail = null;\n return entry.item;\n }\n }\n};\n\nmodule.exports = Queue;\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar Queue = require('../internals/queue');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar microtask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\nvar notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!microtask) {\n var queue = new Queue();\n\n var flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (fn = queue.get()) try {\n fn();\n } catch (error) {\n if (queue.head) notify();\n throw error;\n }\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessage\n // - onreadystatechange\n // - setTimeout\n } else {\n // `webpack` dev server bug on IE global methods - use bind(fn, global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n\n microtask = function (fn) {\n if (!queue.head) notify();\n queue.add(fn);\n };\n}\n\nmodule.exports = microtask;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","'use strict';\nvar global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n && typeof window == 'object'\n && typeof document == 'object';\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n // Detect correctness of subclassing with @@species support\n var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar $TypeError = TypeError;\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar IS_NODE = require('../internals/engine-is-node');\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar perform = require('../internals/perform');\nvar Queue = require('../internals/queue');\nvar InternalStateModule = require('../internals/internal-state');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar PromiseConstructorDetection = require('../internals/promise-constructor-detection');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\n\nvar PROMISE = 'Promise';\nvar FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;\nvar NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;\nvar NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar PromiseConstructor = NativePromiseConstructor;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar callReaction = function (reaction, state) {\n var value = state.value;\n var ok = state.state === FULFILLED;\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(new TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n microtask(function () {\n var reactions = state.reactions;\n var reaction;\n while (reaction = reactions.get()) {\n callReaction(reaction, state);\n }\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw new TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED_PROMISE_CONSTRUCTOR) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalPromiseState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n\n PromisePrototype = PromiseConstructor.prototype;\n\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: new Queue(),\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n state.parent = true;\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n if (state.state === PENDING) state.reactions.add(reaction);\n else microtask(function () {\n callReaction(reaction, state);\n });\n return reaction.promise;\n });\n\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalPromiseState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!NATIVE_PROMISE_SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n","'use strict';\nmodule.exports = function (a, b) {\n try {\n // eslint-disable-next-line no-console -- safe\n arguments.length === 1 ? console.error(a) : console.error(a, b);\n } catch (error) { /* empty */ }\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw new $TypeError(tryToString(argument) + ' is not iterable');\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_RECORD = !!(options && options.IS_RECORD);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_RECORD) {\n iterator = iterable.iterator;\n } else if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = IS_RECORD ? iterable.next : iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n try {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n } catch (error) { return false; } // workaround of old WebKit + `eval` bug\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.all` method\n// https://tc39.es/ecma262/#sec-promise.all\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar defineBuiltIn = require('../internals/define-built-in');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\n\n// `Promise.prototype.catch` method\n// https://tc39.es/ecma262/#sec-promise.prototype.catch\n$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n});\n\n// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromiseConstructor)) {\n var method = getBuiltIn('Promise').prototype['catch'];\n if (NativePromisePrototype['catch'] !== method) {\n defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.race` method\n// https://tc39.es/ecma262/#sec-promise.race\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\n// `Promise.reject` method\n// https://tc39.es/ecma262/#sec-promise.reject\n$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n reject: function reject(r) {\n var capability = newPromiseCapabilityModule.f(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar promiseResolve = require('../internals/promise-resolve');\n\nvar PromiseConstructorWrapper = getBuiltIn('Promise');\nvar CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;\n\n// `Promise.resolve` method\n// https://tc39.es/ecma262/#sec-promise.resolve\n$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {\n resolve: function resolve(x) {\n return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);\n }\n});\n","import {ascending, descending} from \"d3\";\n\nexport function defined(x) {\n return x != null && !Number.isNaN(x);\n}\n\nexport function ascendingDefined(a, b) {\n return +defined(b) - +defined(a) || ascending(a, b);\n}\n\nexport function descendingDefined(a, b) {\n return +defined(b) - +defined(a) || descending(a, b);\n}\n\nexport function nonempty(x) {\n return x != null && `${x}` !== \"\";\n}\n\nexport function finite(x) {\n return isFinite(x) ? x : NaN;\n}\n\nexport function positive(x) {\n return x > 0 && isFinite(x) ? x : NaN;\n}\n\nexport function negative(x) {\n return x < 0 && isFinite(x) ? x : NaN;\n}\n","export default function format(date, fallback) {\n if (!(date instanceof Date)) date = new Date(+date);\n if (isNaN(date)) return typeof fallback === \"function\" ? fallback(date) : fallback;\n const hours = date.getUTCHours();\n const minutes = date.getUTCMinutes();\n const seconds = date.getUTCSeconds();\n const milliseconds = date.getUTCMilliseconds();\n return `${formatYear(date.getUTCFullYear(), 4)}-${pad(date.getUTCMonth() + 1, 2)}-${pad(date.getUTCDate(), 2)}${\n hours || minutes || seconds || milliseconds ? `T${pad(hours, 2)}:${pad(minutes, 2)}${\n seconds || milliseconds ? `:${pad(seconds, 2)}${\n milliseconds ? `.${pad(milliseconds, 3)}` : ``\n }` : ``\n }Z` : ``\n }`;\n}\n\nfunction formatYear(year) {\n return year < 0 ? `-${pad(-year, 6)}`\n : year > 9999 ? `+${pad(year, 6)}`\n : pad(year, 4);\n}\n\nfunction pad(value, width) {\n return `${value}`.padStart(width, \"0\");\n}\n","const re = /^(?:[-+]\\d{2})?\\d{4}(?:-\\d{2}(?:-\\d{2})?)?(?:T\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{3})?)?(?:Z|[-+]\\d{2}:?\\d{2})?)?$/;\n\nexport default function parse(string, fallback) {\n if (!re.test(string += \"\")) return typeof fallback === \"function\" ? fallback(string) : fallback;\n return new Date(string);\n}\n","import {utcSecond, utcMinute, utcHour, utcDay, utcWeek, utcMonth, utcYear} from \"d3\";\nimport {utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSunday} from \"d3\";\nimport {timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear} from \"d3\";\nimport {timeMonday, timeTuesday, timeWednesday, timeThursday, timeFriday, timeSaturday, timeSunday} from \"d3\";\n\nconst timeIntervals = new Map([\n [\"second\", timeSecond],\n [\"minute\", timeMinute],\n [\"hour\", timeHour],\n [\"day\", timeDay],\n [\"week\", timeWeek],\n [\"month\", timeMonth],\n [\"quarter\", timeMonth.every(3)],\n [\"half\", timeMonth.every(6)],\n [\"year\", timeYear],\n [\"monday\", timeMonday],\n [\"tuesday\", timeTuesday],\n [\"wednesday\", timeWednesday],\n [\"thursday\", timeThursday],\n [\"friday\", timeFriday],\n [\"saturday\", timeSaturday],\n [\"sunday\", timeSunday]\n]);\n\nconst utcIntervals = new Map([\n [\"second\", utcSecond],\n [\"minute\", utcMinute],\n [\"hour\", utcHour],\n [\"day\", utcDay],\n [\"week\", utcWeek],\n [\"month\", utcMonth],\n [\"quarter\", utcMonth.every(3)],\n [\"half\", utcMonth.every(6)],\n [\"year\", utcYear],\n [\"monday\", utcMonday],\n [\"tuesday\", utcTuesday],\n [\"wednesday\", utcWednesday],\n [\"thursday\", utcThursday],\n [\"friday\", utcFriday],\n [\"saturday\", utcSaturday],\n [\"sunday\", utcSunday]\n]);\n\nexport function maybeTimeInterval(interval) {\n const i = timeIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n\nexport function maybeUtcInterval(interval) {\n const i = utcIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n","import {parse as isoParse} from \"isoformat\";\nimport {color, descending, range as rangei, quantile} from \"d3\";\nimport {maybeTimeInterval, maybeUtcInterval} from \"./time.js\";\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\nexport const TypedArray = Object.getPrototypeOf(Uint8Array);\nconst objectToString = Object.prototype.toString;\n\nexport function valueof(data, value, type) {\n const valueType = typeof value;\n return valueType === \"string\"\n ? maybeTypedMap(data, field(value), type)\n : valueType === \"function\"\n ? maybeTypedMap(data, value, type)\n : valueType === \"number\" || value instanceof Date || valueType === \"boolean\"\n ? map(data, constant(value), type)\n : typeof value?.transform === \"function\"\n ? maybeTypedArrayify(value.transform(data), type)\n : maybeTypedArrayify(value, type);\n}\n\nfunction maybeTypedMap(data, f, type) {\n return map(data, type?.prototype instanceof TypedArray ? floater(f) : f, type);\n}\n\nfunction maybeTypedArrayify(data, type) {\n return type === undefined\n ? arrayify(data) // preserve undefined type\n : data instanceof type\n ? data\n : type.prototype instanceof TypedArray && !(data instanceof TypedArray)\n ? type.from(data, coerceNumber)\n : type.from(data);\n}\n\nfunction floater(f) {\n return (d, i) => coerceNumber(f(d, i));\n}\n\nexport const field = (name) => (d) => d[name];\nexport const indexOf = {transform: range};\nexport const identity = {transform: (d) => d};\nexport const zero = () => 0;\nexport const one = () => 1;\nexport const yes = () => true;\nexport const string = (x) => (x == null ? x : `${x}`);\nexport const number = (x) => (x == null ? x : +x);\nexport const boolean = (x) => (x == null ? x : !!x);\nexport const first = (x) => (x ? x[0] : undefined);\nexport const second = (x) => (x ? x[1] : undefined);\nexport const third = (x) => (x ? x[2] : undefined);\nexport const constant = (x) => () => x;\n\n// Converts a string like “p25” into a function that takes an index I and an\n// accessor function f, returning the corresponding percentile value.\nexport function percentile(reduce) {\n const p = +`${reduce}`.slice(1) / 100;\n return (I, f) => quantile(I, p, f);\n}\n\n// If the values are specified as a typed array, no coercion is required.\nexport function coerceNumbers(values) {\n return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array);\n}\n\n// Unlike Mark’s number, here we want to convert null and undefined to NaN since\n// the result will be stored in a Float64Array and we don’t want null to be\n// coerced to zero. We use Number instead of unary + to allow BigInt coercion.\nfunction coerceNumber(x) {\n return x == null ? NaN : Number(x);\n}\n\nexport function coerceDates(values) {\n return map(values, coerceDate);\n}\n\n// When coercing strings to dates, we only want to allow the ISO 8601 format\n// since the built-in string parsing of the Date constructor varies across\n// browsers. (In the future, this could be made more liberal if desired, though\n// it is still generally preferable to do date parsing yourself explicitly,\n// rather than rely on Plot.) Any non-string values are coerced to number first\n// and treated as milliseconds since UNIX epoch.\nexport function coerceDate(x) {\n return x instanceof Date && !isNaN(x)\n ? x\n : typeof x === \"string\"\n ? isoParse(x)\n : x == null || isNaN((x = +x))\n ? undefined\n : new Date(x);\n}\n\n// Some channels may allow a string constant to be specified; to differentiate\n// string constants (e.g., \"red\") from named fields (e.g., \"date\"), this\n// function tests whether the given value is a CSS color string and returns a\n// tuple [channel, constant] where one of the two is undefined, and the other is\n// the given value. If you wish to reference a named field that is also a valid\n// CSS color, use an accessor (d => d.red) instead.\nexport function maybeColorChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null ? [undefined, \"none\"] : isColor(value) ? [undefined, value] : [value, undefined];\n}\n\n// Similar to maybeColorChannel, this tests whether the given value is a number\n// indicating a constant, and otherwise assumes that it’s a channel value.\nexport function maybeNumberChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null || typeof value === \"number\" ? [undefined, value] : [value, undefined];\n}\n\n// Validates the specified optional string against the allowed list of keywords.\nexport function maybeKeyword(input, name, allowed) {\n if (input != null) return keyword(input, name, allowed);\n}\n\n// Validates the specified required string against the allowed list of keywords.\nexport function keyword(input, name, allowed) {\n const i = `${input}`.toLowerCase();\n if (!allowed.includes(i)) throw new Error(`invalid ${name}: ${input}`);\n return i;\n}\n\n// Promotes the specified data to an array as needed.\nexport function arrayify(data) {\n return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data);\n}\n\n// An optimization of type.from(values, f): if the given values are already an\n// instanceof the desired array type, the faster values.map method is used.\nexport function map(values, f, type = Array) {\n return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f);\n}\n\n// An optimization of type.from(values): if the given values are already an\n// instanceof the desired array type, the faster values.slice method is used.\nexport function slice(values, type = Array) {\n return values instanceof type ? values.slice() : type.from(values);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a primitive value.\nexport function isObject(option) {\n return option?.toString === objectToString;\n}\n\n// Disambiguates a scale options object (e.g., {color: {type: \"linear\"}}) from\n// some other option (e.g., {color: \"red\"}). When creating standalone legends,\n// this is used to test whether a scale is defined; this should be consistent\n// with inferScaleType when there are no channels associated with the scale, and\n// if this returns true, then normalizeScale must return non-null.\nexport function isScaleOptions(option) {\n return isObject(option) && (option.type !== undefined || option.domain !== undefined);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a channel value\n// definition expressed as a channel transform (e.g., {transform: …}).\nexport function isOptions(option) {\n return isObject(option) && typeof option.transform !== \"function\";\n}\n\n// Disambiguates a sort transform (e.g., {sort: \"date\"}) from a channel domain\n// sort definition (e.g., {sort: {y: \"x\"}}).\nexport function isDomainSort(sort) {\n return isOptions(sort) && sort.value === undefined && sort.channel === undefined;\n}\n\n// For marks specified either as [0, x] or [x1, x2], such as areas and bars.\nexport function maybeZero(x, x1, x2, x3 = identity) {\n if (x1 === undefined && x2 === undefined) {\n // {x} or {}\n (x1 = 0), (x2 = x === undefined ? x3 : x);\n } else if (x1 === undefined) {\n // {x, x2} or {x2}\n x1 = x === undefined ? 0 : x;\n } else if (x2 === undefined) {\n // {x, x1} or {x1}\n x2 = x === undefined ? 0 : x;\n }\n return [x1, x2];\n}\n\n// For marks that have x and y channels (e.g., cell, dot, line, text).\nexport function maybeTuple(x, y) {\n return x === undefined && y === undefined ? [first, second] : [x, y];\n}\n\n// A helper for extracting the z channel, if it is variable. Used by transforms\n// that require series, such as moving average and normalize.\nexport function maybeZ({z, fill, stroke} = {}) {\n if (z === undefined) [z] = maybeColorChannel(fill);\n if (z === undefined) [z] = maybeColorChannel(stroke);\n return z;\n}\n\n// Returns a Uint32Array with elements [0, 1, 2, … data.length - 1].\nexport function range(data) {\n const n = data.length;\n const r = new Uint32Array(n);\n for (let i = 0; i < n; ++i) r[i] = i;\n return r;\n}\n\n// Returns a filtered range of data given the test function.\nexport function where(data, test) {\n return range(data).filter((i) => test(data[i], i, data));\n}\n\n// Returns an array [values[index[0]], values[index[1]], …].\nexport function take(values, index) {\n return map(index, (i) => values[i]);\n}\n\n// Based on InternMap (d3.group).\nexport function keyof(value) {\n return value !== null && typeof value === \"object\" ? value.valueOf() : value;\n}\n\nexport function maybeInput(key, options) {\n if (options[key] !== undefined) return options[key];\n switch (key) {\n case \"x1\":\n case \"x2\":\n key = \"x\";\n break;\n case \"y1\":\n case \"y2\":\n key = \"y\";\n break;\n }\n return options[key];\n}\n\nexport function column(source) {\n // Defines a column whose values are lazily populated by calling the returned\n // setter. If the given source is labeled, the label is propagated to the\n // returned column definition.\n let value;\n return [\n {\n transform: () => value,\n label: labelof(source)\n },\n (v) => (value = v)\n ];\n}\n\n// Like column, but allows the source to be null.\nexport function maybeColumn(source) {\n return source == null ? [source] : column(source);\n}\n\nexport function labelof(value, defaultValue) {\n return typeof value === \"string\" ? value : value && value.label !== undefined ? value.label : defaultValue;\n}\n\n// Assuming that both x1 and x2 and lazy columns (per above), this derives a new\n// a column that’s the average of the two, and which inherits the column label\n// (if any). Both input columns are assumed to be quantitative. If either column\n// is temporal, the returned column is also temporal.\nexport function mid(x1, x2) {\n return {\n transform(data) {\n const X1 = x1.transform(data);\n const X2 = x2.transform(data);\n return isTemporal(X1) || isTemporal(X2)\n ? map(X1, (_, i) => new Date((+X1[i] + +X2[i]) / 2))\n : map(X1, (_, i) => (+X1[i] + +X2[i]) / 2, Float64Array);\n },\n label: x1.label\n };\n}\n\n// If interval is not nullish, converts interval shorthand such as a number (for\n// multiples) or a time interval name (such as “day”) to a {floor, offset,\n// range} object similar to a D3 time interval.\nexport function maybeInterval(interval, type) {\n if (interval == null) return;\n if (typeof interval === \"number\") {\n if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval;\n const n = Math.abs(interval);\n return interval < 0\n ? {\n floor: (d) => Math.floor(d * n) / n,\n offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo * n), hi * n).map((x) => x / n)\n }\n : {\n floor: (d) => Math.floor(d / n) * n,\n offset: (d) => d + n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo / n), hi / n).map((x) => x * n)\n };\n }\n if (typeof interval === \"string\") return (type === \"time\" ? maybeTimeInterval : maybeUtcInterval)(interval);\n if (typeof interval.floor !== \"function\") throw new Error(\"invalid interval; missing floor method\");\n if (typeof interval.offset !== \"function\") throw new Error(\"invalid interval; missing offset method\");\n return interval;\n}\n\n// Like maybeInterval, but requires a range method too.\nexport function maybeRangeInterval(interval, type) {\n interval = maybeInterval(interval, type);\n if (interval && typeof interval.range !== \"function\") throw new Error(\"invalid interval: missing range method\");\n return interval;\n}\n\n// Like maybeRangeInterval, but requires a ceil method too.\nexport function maybeNiceInterval(interval, type) {\n interval = maybeRangeInterval(interval, type);\n if (interval && typeof interval.ceil !== \"function\") throw new Error(\"invalid interval: missing ceil method\");\n return interval;\n}\n\n// This distinguishes between per-dimension options and a standalone value.\nexport function maybeValue(value) {\n return value === undefined || isOptions(value) ? value : {value};\n}\n\n// Coerces the given channel values (if any) to numbers. This is useful when\n// values will be interpolated into other code, such as an SVG transform, and\n// where we don’t wish to allow unexpected behavior for weird input.\nexport function numberChannel(source) {\n return source == null\n ? null\n : {\n transform: (data) => valueof(data, source, Float64Array),\n label: labelof(source)\n };\n}\n\nexport function isTuples(data) {\n if (!isIterable(data)) return false;\n for (const d of data) {\n if (d == null) continue;\n return typeof d === \"object\" && \"0\" in d && \"1\" in d;\n }\n}\n\nexport function isIterable(value) {\n return value && typeof value[Symbol.iterator] === \"function\";\n}\n\nexport function isTextual(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value !== \"object\" || value instanceof Date;\n }\n}\n\nexport function isOrdinal(values) {\n for (const value of values) {\n if (value == null) continue;\n const type = typeof value;\n return type === \"string\" || type === \"boolean\";\n }\n}\n\nexport function isTemporal(values) {\n for (const value of values) {\n if (value == null) continue;\n return value instanceof Date;\n }\n}\n\n// Are these strings that might represent dates? This is stricter than ISO 8601\n// because we want to ignore false positives on numbers; for example, the string\n// \"1192\" is more likely to represent a number than a date even though it is\n// valid ISO 8601 representing 1192-01-01.\nexport function isTemporalString(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"string\" && isNaN(value) && isoParse(value);\n }\n}\n\n// Are these strings that might represent numbers? This is stricter than\n// coercion because we want to ignore false positives on e.g. empty strings.\nexport function isNumericString(values) {\n for (const value of values) {\n if (value == null) continue;\n if (typeof value !== \"string\") return false;\n if (!value.trim()) continue;\n return !isNaN(value);\n }\n}\n\nexport function isNumeric(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"number\";\n }\n}\n\n// Returns true if every non-null value in the specified iterable of values\n// passes the specified predicate, and there is at least one non-null value;\n// returns false if at least one non-null value does not pass the specified\n// predicate; otherwise returns undefined (as if all values are null).\nexport function isEvery(values, is) {\n let every;\n for (const value of values) {\n if (value == null) continue;\n if (!is(value)) return false;\n every = true;\n }\n return every;\n}\n\n// Mostly relies on d3-color, with a few extra color keywords. Currently this\n// strictly requires that the value be a string; we might want to apply string\n// coercion here, though note that d3-color instances would need to support\n// valueOf to work correctly with InternMap.\n// https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint\nexport function isColor(value) {\n if (typeof value !== \"string\") return false;\n value = value.toLowerCase().trim();\n return (\n value === \"none\" ||\n value === \"currentcolor\" ||\n (value.startsWith(\"url(\") && value.endsWith(\")\")) || // , e.g. pattern or gradient\n (value.startsWith(\"var(\") && value.endsWith(\")\")) || // CSS variable\n color(value) !== null\n );\n}\n\nexport function isOpacity(value) {\n return typeof value === \"number\" && ((0 <= value && value <= 1) || isNaN(value));\n}\n\nexport function isNoneish(value) {\n return value == null || isNone(value);\n}\n\nexport function isNone(value) {\n return /^\\s*none\\s*$/i.test(value);\n}\n\nexport function isRound(value) {\n return /^\\s*round\\s*$/i.test(value);\n}\n\nexport function maybeFrameAnchor(value = \"middle\") {\n return keyword(value, \"frameAnchor\", [\n \"middle\",\n \"top-left\",\n \"top\",\n \"top-right\",\n \"right\",\n \"bottom-right\",\n \"bottom\",\n \"bottom-left\",\n \"left\"\n ]);\n}\n\n// Like a sort comparator, returns a positive value if the given array of values\n// is in ascending order, a negative value if the values are in descending\n// order. Assumes monotonicity; only tests the first and last values.\nexport function orderof(values) {\n if (values == null) return;\n const first = values[0];\n const last = values[values.length - 1];\n return descending(first, last);\n}\n\n// Unlike {...defaults, ...options}, this ensures that any undefined (but\n// present) properties in options inherit the given default value.\nexport function inherit(options = {}, ...rest) {\n let o = options;\n for (const defaults of rest) {\n for (const key in defaults) {\n if (o[key] === undefined) {\n const value = defaults[key];\n if (o === options) o = {...o, [key]: value};\n else o[key] = value;\n }\n }\n }\n return o;\n}\n\n// Given an iterable of named things (objects with a name property), returns a\n// corresponding object with properties associated with the given name.\nexport function named(things) {\n console.warn(\"named iterables are deprecated; please use an object instead\");\n const names = new Set();\n return Object.fromEntries(\n Array.from(things, (thing) => {\n const {name} = thing;\n if (name == null) throw new Error(\"missing name\");\n const key = `${name}`;\n if (key === \"__proto__\") throw new Error(`illegal name: ${key}`);\n if (names.has(key)) throw new Error(`duplicate name: ${key}`);\n names.add(key);\n return [name, thing];\n })\n );\n}\n\nexport function maybeNamed(things) {\n return isIterable(things) ? named(things) : things;\n}\n","// Positional scales have associated axes, and for ordinal data, a point or band\n// scale is used instead of an ordinal scale.\nexport const position = Symbol(\"position\");\n\n// Color scales default to the turbo interpolator for quantitative data, and to\n// the Tableau10 scheme for ordinal data. Color scales may also have an\n// associated legend.\nexport const color = Symbol(\"color\");\n\n// Radius scales default to the sqrt type, have a default range of [0, 3], and a\n// default domain from 0 to the median first quartile of associated channels.\nexport const radius = Symbol(\"radius\");\n\n// Length scales default to the linear type, have a default range of [0, 12],\n// and a default domain from 0 to the median median of associated channels.\nexport const length = Symbol(\"length\");\n\n// Opacity scales have a default range of [0, 1], and a default domain from 0 to\n// the maximum value of associated channels.\nexport const opacity = Symbol(\"opacity\");\n\n// Symbol scales have a default range of categorical symbols.\nexport const symbol = Symbol(\"symbol\");\n\n// TODO Rather than hard-coding the list of known scale names, collect the names\n// and categories for each plot specification, so that custom marks can register\n// custom scales.\nexport const registry = new Map([\n [\"x\", position],\n [\"y\", position],\n [\"fx\", position],\n [\"fy\", position],\n [\"r\", radius],\n [\"color\", color],\n [\"opacity\", opacity],\n [\"symbol\", symbol],\n [\"length\", length]\n]);\n","import {symbolAsterisk, symbolDiamond2, symbolPlus, symbolSquare2, symbolTriangle2, symbolTimes} from \"d3\";\nimport {symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye} from \"d3\";\n\nexport const sqrt3 = Math.sqrt(3);\nexport const sqrt4_3 = 2 / sqrt3;\n\nconst symbolHexagon = {\n draw(context, size) {\n const rx = Math.sqrt(size / Math.PI),\n ry = rx * sqrt4_3,\n hy = ry / 2;\n context.moveTo(0, ry);\n context.lineTo(rx, hy);\n context.lineTo(rx, -hy);\n context.lineTo(0, -ry);\n context.lineTo(-rx, -hy);\n context.lineTo(-rx, hy);\n context.closePath();\n }\n};\n\nconst symbols = new Map([\n [\"asterisk\", symbolAsterisk],\n [\"circle\", symbolCircle],\n [\"cross\", symbolCross],\n [\"diamond\", symbolDiamond],\n [\"diamond2\", symbolDiamond2],\n [\"hexagon\", symbolHexagon],\n [\"plus\", symbolPlus],\n [\"square\", symbolSquare],\n [\"square2\", symbolSquare2],\n [\"star\", symbolStar],\n [\"times\", symbolTimes],\n [\"triangle\", symbolTriangle],\n [\"triangle2\", symbolTriangle2],\n [\"wye\", symbolWye]\n]);\n\nfunction isSymbolObject(value) {\n return value && typeof value.draw === \"function\";\n}\n\nexport function isSymbol(value) {\n if (isSymbolObject(value)) return true;\n if (typeof value !== \"string\") return false;\n return symbols.has(value.toLowerCase());\n}\n\nexport function maybeSymbol(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return symbol;\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return value;\n throw new Error(`invalid symbol: ${symbol}`);\n}\n\nexport function maybeSymbolChannel(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return [undefined, symbol];\n if (typeof symbol === \"string\") {\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return [undefined, value];\n }\n return [symbol, undefined];\n}\n","let warnings = 0;\n\nexport function consumeWarnings() {\n const w = warnings;\n warnings = 0;\n return w;\n}\n\nexport function warn(message) {\n console.warn(message);\n ++warnings;\n}\n","import {\n geoAlbers,\n geoAlbersUsa,\n geoAzimuthalEqualArea,\n geoAzimuthalEquidistant,\n geoClipRectangle,\n geoConicConformal,\n geoConicEqualArea,\n geoConicEquidistant,\n geoEqualEarth,\n geoEquirectangular,\n geoGnomonic,\n geoMercator,\n geoOrthographic,\n geoPath,\n geoStereographic,\n geoTransform,\n geoTransverseMercator\n} from \"d3\";\nimport {valueObject} from \"./channel.js\";\nimport {coerceNumbers, constant, isObject} from \"./options.js\";\nimport {warn} from \"./warnings.js\";\n\nconst pi = Math.PI;\nconst tau = 2 * pi;\nconst defaultAspectRatio = 0.618;\n\nexport function createProjection(\n {\n projection,\n inset: globalInset = 0,\n insetTop = globalInset,\n insetRight = globalInset,\n insetBottom = globalInset,\n insetLeft = globalInset\n } = {},\n dimensions\n) {\n if (projection == null) return;\n if (typeof projection.stream === \"function\") return projection; // d3 projection\n let options;\n let domain;\n let clip = \"frame\";\n\n // If the projection was specified as an object with additional options,\n // extract those. The order of precedence for insetTop (and other insets) is:\n // projection.insetTop, projection.inset, (global) insetTop, (global) inset.\n // Any other options on this object will be passed through to the initializer.\n if (isObject(projection)) {\n let inset;\n ({\n type: projection,\n domain,\n inset,\n insetTop = inset !== undefined ? inset : insetTop,\n insetRight = inset !== undefined ? inset : insetRight,\n insetBottom = inset !== undefined ? inset : insetBottom,\n insetLeft = inset !== undefined ? inset : insetLeft,\n clip = clip,\n ...options\n } = projection);\n if (projection == null) return;\n }\n\n // For named projections, retrieve the corresponding projection initializer.\n if (typeof projection !== \"function\") ({type: projection} = namedProjection(projection));\n\n // Compute the frame dimensions and invoke the projection initializer.\n const {width, height, marginLeft, marginRight, marginTop, marginBottom} = dimensions;\n const dx = width - marginLeft - marginRight - insetLeft - insetRight;\n const dy = height - marginTop - marginBottom - insetTop - insetBottom;\n projection = projection?.({width: dx, height: dy, clip, ...options});\n\n // The projection initializer might decide to not use a projection.\n if (projection == null) return;\n clip = maybePostClip(clip, marginLeft, marginTop, width - marginRight, height - marginBottom);\n\n // Translate the origin to the top-left corner, respecting margins and insets.\n let tx = marginLeft + insetLeft;\n let ty = marginTop + insetTop;\n let transform;\n\n // If a domain is specified, fit the projection to the frame.\n if (domain != null) {\n const [[x0, y0], [x1, y1]] = geoPath(projection).bounds(domain);\n const k = Math.min(dx / (x1 - x0), dy / (y1 - y0));\n if (k > 0) {\n tx -= (k * (x0 + x1) - dx) / 2;\n ty -= (k * (y0 + y1) - dy) / 2;\n transform = geoTransform({\n point(x, y) {\n this.stream.point(x * k + tx, y * k + ty);\n }\n });\n } else {\n warn(`Warning: the projection could not be fit to the specified domain; using the default scale.`);\n }\n }\n\n transform ??=\n tx === 0 && ty === 0\n ? identity()\n : geoTransform({\n point(x, y) {\n this.stream.point(x + tx, y + ty);\n }\n });\n\n return {stream: (s) => projection.stream(transform.stream(clip(s)))};\n}\n\nfunction namedProjection(projection) {\n switch (`${projection}`.toLowerCase()) {\n case \"albers-usa\":\n return scaleProjection(geoAlbersUsa, 0.7463, 0.4673);\n case \"albers\":\n return conicProjection(geoAlbers, 0.7463, 0.4673);\n case \"azimuthal-equal-area\":\n return scaleProjection(geoAzimuthalEqualArea, 4, 4);\n case \"azimuthal-equidistant\":\n return scaleProjection(geoAzimuthalEquidistant, tau, tau);\n case \"conic-conformal\":\n return conicProjection(geoConicConformal, tau, tau);\n case \"conic-equal-area\":\n return conicProjection(geoConicEqualArea, 6.1702, 2.9781);\n case \"conic-equidistant\":\n return conicProjection(geoConicEquidistant, 7.312, 3.6282);\n case \"equal-earth\":\n return scaleProjection(geoEqualEarth, 5.4133, 2.6347);\n case \"equirectangular\":\n return scaleProjection(geoEquirectangular, tau, pi);\n case \"gnomonic\":\n return scaleProjection(geoGnomonic, 3.4641, 3.4641);\n case \"identity\":\n return {type: identity};\n case \"reflect-y\":\n return {type: reflectY};\n case \"mercator\":\n return scaleProjection(geoMercator, tau, tau);\n case \"orthographic\":\n return scaleProjection(geoOrthographic, 2, 2);\n case \"stereographic\":\n return scaleProjection(geoStereographic, 2, 2);\n case \"transverse-mercator\":\n return scaleProjection(geoTransverseMercator, tau, tau);\n default:\n throw new Error(`unknown projection type: ${projection}`);\n }\n}\n\nfunction maybePostClip(clip, x1, y1, x2, y2) {\n if (clip === false || clip == null || typeof clip === \"number\") return (s) => s;\n if (clip === true) clip = \"frame\";\n switch (`${clip}`.toLowerCase()) {\n case \"frame\":\n return geoClipRectangle(x1, y1, x2, y2);\n default:\n throw new Error(`unknown projection clip type: ${clip}`);\n }\n}\n\nfunction scaleProjection(createProjection, kx, ky) {\n return {\n type: ({width, height, rotate, precision = 0.15, clip}) => {\n const projection = createProjection();\n if (precision != null) projection.precision?.(precision);\n if (rotate != null) projection.rotate?.(rotate);\n if (typeof clip === \"number\") projection.clipAngle?.(clip);\n projection.scale(Math.min(width / kx, height / ky));\n projection.translate([width / 2, height / 2]);\n return projection;\n },\n aspectRatio: ky / kx\n };\n}\n\nfunction conicProjection(createProjection, kx, ky) {\n const {type, aspectRatio} = scaleProjection(createProjection, kx, ky);\n return {\n type: (options) => {\n const {parallels, domain, width, height} = options;\n const projection = type(options);\n if (parallels != null) {\n projection.parallels(parallels);\n if (domain === undefined) {\n projection.fitSize([width, height], {type: \"Sphere\"});\n }\n }\n return projection;\n },\n aspectRatio\n };\n}\n\nconst identity = constant({stream: (stream) => stream});\n\nconst reflectY = constant(\n geoTransform({\n point(x, y) {\n this.stream.point(x, -y);\n }\n })\n);\n\n// Applies a point-wise projection to the given paired x and y channels.\n// Note: mutates values!\nexport function maybeProject(cx, cy, channels, values, context) {\n const x = channels[cx] && channels[cx].scale === \"x\";\n const y = channels[cy] && channels[cy].scale === \"y\";\n if (x && y) {\n project(cx, cy, values, context.projection);\n } else if (x) {\n throw new Error(`projection requires paired x and y channels; ${cx} is missing ${cy}`);\n } else if (y) {\n throw new Error(`projection requires paired x and y channels; ${cy} is missing ${cx}`);\n }\n}\n\nfunction project(cx, cy, values, projection) {\n const x = values[cx];\n const y = values[cy];\n const n = x.length;\n const X = (values[cx] = new Float64Array(n).fill(NaN));\n const Y = (values[cy] = new Float64Array(n).fill(NaN));\n let i;\n const stream = projection.stream({\n point(x, y) {\n X[i] = x;\n Y[i] = y;\n }\n });\n for (i = 0; i < n; ++i) {\n stream.point(x[i], y[i]);\n }\n}\n\n// When a named projection is specified, we can use its natural aspect ratio to\n// determine a good value for the projection’s height based on the desired\n// width. When we don’t have a way to know, the golden ratio is our best guess.\n// Due to a circular dependency (we need to know the height before we can\n// construct the projection), we have to test the raw projection option rather\n// than the materialized projection; therefore we must be extremely careful that\n// the logic of this function exactly matches Projection above!\nexport function projectionAspectRatio(projection, marks) {\n if (typeof projection?.stream === \"function\") return defaultAspectRatio;\n if (isObject(projection)) projection = projection.type;\n if (projection == null) return hasGeometry(marks) ? defaultAspectRatio : undefined;\n if (typeof projection !== \"function\") {\n const {aspectRatio} = namedProjection(projection);\n if (aspectRatio) return aspectRatio;\n }\n return defaultAspectRatio;\n}\n\n// Extract the (possibly) scaled values for the x and y channels, and apply the\n// projection if any.\nexport function applyPosition(channels, scales, context) {\n const {x, y} = channels;\n let position = {};\n if (x) position.x = x;\n if (y) position.y = y;\n position = valueObject(position, scales);\n if (context.projection) maybeProject(\"x\", \"y\", channels, position, context);\n if (x) position.x = coerceNumbers(position.x);\n if (y) position.y = coerceNumbers(position.y);\n return position;\n}\n\nfunction hasGeometry(marks) {\n for (const mark of marks) if (mark.channels.geometry) return true;\n return false;\n}\n","import {creator, select} from \"d3\";\nimport {createProjection} from \"./projection.js\";\n\nexport function createContext(options = {}, dimensions, className) {\n const {document = typeof window !== \"undefined\" ? window.document : undefined} = options;\n return {document, className, projection: createProjection(options, dimensions)};\n}\n\nexport function create(name, {document}) {\n return select(creator(name).call(document.documentElement));\n}\n","import {\n interpolateBlues,\n interpolateBrBG,\n interpolateBuGn,\n interpolateBuPu,\n interpolateGnBu,\n interpolateGreens,\n interpolateGreys,\n interpolateOranges,\n interpolateOrRd,\n interpolatePiYG,\n interpolatePRGn,\n interpolatePuBu,\n interpolatePuBuGn,\n interpolatePuOr,\n interpolatePuRd,\n interpolatePurples,\n interpolateRdBu,\n interpolateRdGy,\n interpolateRdPu,\n interpolateRdYlBu,\n interpolateRdYlGn,\n interpolateReds,\n interpolateSpectral,\n interpolateYlGn,\n interpolateYlGnBu,\n interpolateYlOrBr,\n interpolateYlOrRd,\n interpolateTurbo,\n interpolateViridis,\n interpolateMagma,\n interpolateInferno,\n interpolatePlasma,\n interpolateCividis,\n interpolateCubehelixDefault,\n interpolateWarm,\n interpolateCool,\n interpolateRainbow,\n interpolateSinebow,\n quantize,\n schemeAccent,\n schemeBlues,\n schemeBrBG,\n schemeBuGn,\n schemeBuPu,\n schemeCategory10,\n schemeDark2,\n schemeGnBu,\n schemeGreens,\n schemeGreys,\n schemeOranges,\n schemeOrRd,\n schemePaired,\n schemePastel1,\n schemePastel2,\n schemePiYG,\n schemePRGn,\n schemePuBu,\n schemePuBuGn,\n schemePuOr,\n schemePuRd,\n schemePurples,\n schemeRdBu,\n schemeRdGy,\n schemeRdPu,\n schemeRdYlBu,\n schemeRdYlGn,\n schemeReds,\n schemeSet1,\n schemeSet2,\n schemeSet3,\n schemeSpectral,\n schemeTableau10,\n schemeYlGn,\n schemeYlGnBu,\n schemeYlOrBr,\n schemeYlOrRd\n} from \"d3\";\n\nconst ordinalSchemes = new Map([\n // categorical\n [\"accent\", schemeAccent],\n [\"category10\", schemeCategory10],\n [\"dark2\", schemeDark2],\n [\"paired\", schemePaired],\n [\"pastel1\", schemePastel1],\n [\"pastel2\", schemePastel2],\n [\"set1\", schemeSet1],\n [\"set2\", schemeSet2],\n [\"set3\", schemeSet3],\n [\"tableau10\", schemeTableau10],\n\n // diverging\n [\"brbg\", scheme11(schemeBrBG, interpolateBrBG)],\n [\"prgn\", scheme11(schemePRGn, interpolatePRGn)],\n [\"piyg\", scheme11(schemePiYG, interpolatePiYG)],\n [\"puor\", scheme11(schemePuOr, interpolatePuOr)],\n [\"rdbu\", scheme11(schemeRdBu, interpolateRdBu)],\n [\"rdgy\", scheme11(schemeRdGy, interpolateRdGy)],\n [\"rdylbu\", scheme11(schemeRdYlBu, interpolateRdYlBu)],\n [\"rdylgn\", scheme11(schemeRdYlGn, interpolateRdYlGn)],\n [\"spectral\", scheme11(schemeSpectral, interpolateSpectral)],\n\n // reversed diverging (for temperature data)\n [\"burd\", scheme11r(schemeRdBu, interpolateRdBu)],\n [\"buylrd\", scheme11r(schemeRdYlBu, interpolateRdYlBu)],\n\n // sequential (single-hue)\n [\"blues\", scheme9(schemeBlues, interpolateBlues)],\n [\"greens\", scheme9(schemeGreens, interpolateGreens)],\n [\"greys\", scheme9(schemeGreys, interpolateGreys)],\n [\"oranges\", scheme9(schemeOranges, interpolateOranges)],\n [\"purples\", scheme9(schemePurples, interpolatePurples)],\n [\"reds\", scheme9(schemeReds, interpolateReds)],\n\n // sequential (multi-hue)\n [\"turbo\", schemei(interpolateTurbo)],\n [\"viridis\", schemei(interpolateViridis)],\n [\"magma\", schemei(interpolateMagma)],\n [\"inferno\", schemei(interpolateInferno)],\n [\"plasma\", schemei(interpolatePlasma)],\n [\"cividis\", schemei(interpolateCividis)],\n [\"cubehelix\", schemei(interpolateCubehelixDefault)],\n [\"warm\", schemei(interpolateWarm)],\n [\"cool\", schemei(interpolateCool)],\n [\"bugn\", scheme9(schemeBuGn, interpolateBuGn)],\n [\"bupu\", scheme9(schemeBuPu, interpolateBuPu)],\n [\"gnbu\", scheme9(schemeGnBu, interpolateGnBu)],\n [\"orrd\", scheme9(schemeOrRd, interpolateOrRd)],\n [\"pubu\", scheme9(schemePuBu, interpolatePuBu)],\n [\"pubugn\", scheme9(schemePuBuGn, interpolatePuBuGn)],\n [\"purd\", scheme9(schemePuRd, interpolatePuRd)],\n [\"rdpu\", scheme9(schemeRdPu, interpolateRdPu)],\n [\"ylgn\", scheme9(schemeYlGn, interpolateYlGn)],\n [\"ylgnbu\", scheme9(schemeYlGnBu, interpolateYlGnBu)],\n [\"ylorbr\", scheme9(schemeYlOrBr, interpolateYlOrBr)],\n [\"ylorrd\", scheme9(schemeYlOrRd, interpolateYlOrRd)],\n\n // cyclical\n [\"rainbow\", schemeicyclical(interpolateRainbow)],\n [\"sinebow\", schemeicyclical(interpolateSinebow)]\n]);\n\nfunction scheme9(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 1) return [scheme[3][1]]; // favor midpoint\n if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker\n n = Math.max(3, Math.floor(n));\n return n > 9 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11r(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse();\n };\n}\n\nfunction schemei(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.max(2, Math.floor(n)));\n}\n\nfunction schemeicyclical(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.floor(n) + 1).slice(0, -1);\n}\n\nexport function ordinalScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`);\n return ordinalSchemes.get(s);\n}\n\nexport function ordinalRange(scheme, length) {\n const s = ordinalScheme(scheme);\n const r = typeof s === \"function\" ? s({length}) : s;\n return r.length !== length ? r.slice(0, length) : r;\n}\n\n// If the specified domain contains only booleans (ignoring null and undefined),\n// returns a corresponding range where false is mapped to the low color and true\n// is mapped to the high color of the specified scheme.\nexport function maybeBooleanRange(domain, scheme = \"greys\") {\n const range = new Set();\n const [f, t] = ordinalRange(scheme, 2);\n for (const value of domain) {\n if (value == null) continue;\n if (value === true) range.add(t);\n else if (value === false) range.add(f);\n else return;\n }\n return [...range];\n}\n\nconst quantitativeSchemes = new Map([\n // diverging\n [\"brbg\", interpolateBrBG],\n [\"prgn\", interpolatePRGn],\n [\"piyg\", interpolatePiYG],\n [\"puor\", interpolatePuOr],\n [\"rdbu\", interpolateRdBu],\n [\"rdgy\", interpolateRdGy],\n [\"rdylbu\", interpolateRdYlBu],\n [\"rdylgn\", interpolateRdYlGn],\n [\"spectral\", interpolateSpectral],\n\n // reversed diverging (for temperature data)\n [\"burd\", (t) => interpolateRdBu(1 - t)],\n [\"buylrd\", (t) => interpolateRdYlBu(1 - t)],\n\n // sequential (single-hue)\n [\"blues\", interpolateBlues],\n [\"greens\", interpolateGreens],\n [\"greys\", interpolateGreys],\n [\"purples\", interpolatePurples],\n [\"reds\", interpolateReds],\n [\"oranges\", interpolateOranges],\n\n // sequential (multi-hue)\n [\"turbo\", interpolateTurbo],\n [\"viridis\", interpolateViridis],\n [\"magma\", interpolateMagma],\n [\"inferno\", interpolateInferno],\n [\"plasma\", interpolatePlasma],\n [\"cividis\", interpolateCividis],\n [\"cubehelix\", interpolateCubehelixDefault],\n [\"warm\", interpolateWarm],\n [\"cool\", interpolateCool],\n [\"bugn\", interpolateBuGn],\n [\"bupu\", interpolateBuPu],\n [\"gnbu\", interpolateGnBu],\n [\"orrd\", interpolateOrRd],\n [\"pubugn\", interpolatePuBuGn],\n [\"pubu\", interpolatePuBu],\n [\"purd\", interpolatePuRd],\n [\"rdpu\", interpolateRdPu],\n [\"ylgnbu\", interpolateYlGnBu],\n [\"ylgn\", interpolateYlGn],\n [\"ylorbr\", interpolateYlOrBr],\n [\"ylorrd\", interpolateYlOrRd],\n\n // cyclical\n [\"rainbow\", interpolateRainbow],\n [\"sinebow\", interpolateSinebow]\n]);\n\nexport function quantitativeScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`);\n return quantitativeSchemes.get(s);\n}\n\nconst divergingSchemes = new Set([\n \"brbg\",\n \"prgn\",\n \"piyg\",\n \"puor\",\n \"rdbu\",\n \"rdgy\",\n \"rdylbu\",\n \"rdylgn\",\n \"spectral\",\n \"burd\",\n \"buylrd\"\n]);\n\nexport function isDivergingScheme(scheme) {\n return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase());\n}\n","import {\n descending,\n extent,\n interpolateHcl,\n interpolateHsl,\n interpolateLab,\n interpolateNumber,\n interpolateRgb,\n interpolateRound,\n min,\n max,\n median,\n quantile,\n quantize,\n reverse as reverseof,\n scaleLinear,\n scaleLog,\n scalePow,\n scaleQuantile,\n scaleSymlog,\n scaleThreshold,\n scaleIdentity,\n ticks\n} from \"d3\";\nimport {positive, negative, finite} from \"../defined.js\";\nimport {arrayify, constant, orderof, slice, maybeNiceInterval, maybeRangeInterval} from \"../options.js\";\nimport {ordinalRange, quantitativeScheme} from \"./schemes.js\";\nimport {registry, radius, opacity, color, length} from \"./index.js\";\n\nexport const flip = (i) => (t) => i(1 - t);\nconst unit = [0, 1];\n\nconst interpolators = new Map([\n // numbers\n [\"number\", interpolateNumber],\n\n // color spaces\n [\"rgb\", interpolateRgb],\n [\"hsl\", interpolateHsl],\n [\"hcl\", interpolateHcl],\n [\"lab\", interpolateLab]\n]);\n\nexport function maybeInterpolator(interpolate) {\n const i = `${interpolate}`.toLowerCase();\n if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`);\n return interpolators.get(i);\n}\n\nexport function createScaleQ(\n key,\n scale,\n channels,\n {\n type,\n nice,\n clamp,\n zero,\n domain = inferAutoDomain(key, channels),\n unknown,\n round,\n scheme,\n interval,\n range = registry.get(key) === radius\n ? inferRadialRange(channels, domain)\n : registry.get(key) === length\n ? inferLengthRange(channels, domain)\n : registry.get(key) === opacity\n ? unit\n : undefined,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : type === \"cyclical\" ? \"rainbow\" : \"turbo\")\n : round\n ? interpolateRound\n : interpolateNumber,\n reverse\n }\n) {\n interval = maybeRangeInterval(interval, type);\n if (type === \"cyclical\" || type === \"sequential\") type = \"linear\"; // shorthand for color schemes\n reverse = !!reverse;\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n if (interpolate.length === 1) {\n if (reverse) {\n interpolate = flip(interpolate);\n reverse = false;\n }\n if (range === undefined) {\n range = Float64Array.from(domain, (_, i) => i / (domain.length - 1));\n if (range.length === 2) range = unit; // optimize common case of [0, 1]\n }\n scale.interpolate((range === unit ? constant : interpolatePiecewise)(interpolate));\n } else {\n scale.interpolate(interpolate);\n }\n\n // If a zero option is specified, we assume that the domain is numeric, and we\n // want to ensure that the domain crosses zero. However, note that the domain\n // may be reversed (descending) so we shouldn’t assume that the first value is\n // smaller than the last; and also it’s possible that the domain has more than\n // two values for a “poly” scale. And lastly be careful not to mutate input!\n if (zero) {\n const [min, max] = extent(domain);\n if (min > 0 || max < 0) {\n domain = slice(domain);\n if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0;\n // [2, 1] or [-2, -1]\n else domain[0] = 0; // [1, 2] or [-1, -2]\n }\n }\n\n if (reverse) domain = reverseof(domain);\n scale.domain(domain).unknown(unknown);\n if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain());\n if (range !== undefined) scale.range(range);\n if (clamp) scale.clamp(clamp);\n return {type, domain, range, scale, interpolate, interval};\n}\n\nfunction maybeNice(nice, type) {\n return nice === true ? undefined : typeof nice === \"number\" ? nice : maybeNiceInterval(nice, type);\n}\n\nexport function createScaleLinear(key, channels, options) {\n return createScaleQ(key, scaleLinear(), channels, options);\n}\n\nexport function createScaleSqrt(key, channels, options) {\n return createScalePow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScalePow(key, channels, {exponent = 1, ...options}) {\n return createScaleQ(key, scalePow().exponent(exponent), channels, {...options, type: \"pow\"});\n}\n\nexport function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) {\n return createScaleQ(key, scaleLog().base(base), channels, {...options, domain});\n}\n\nexport function createScaleSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleQ(key, scaleSymlog().constant(constant), channels, options);\n}\n\nexport function createScaleQuantile(\n key,\n channels,\n {\n range,\n quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead\n n = quantiles,\n scheme = \"rdylbu\",\n domain = inferQuantileDomain(channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n if (range === undefined) {\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n }\n if (domain.length > 0) {\n domain = scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles();\n }\n return createScaleThreshold(key, channels, {domain, range, reverse, unknown});\n}\n\nexport function createScaleQuantize(\n key,\n channels,\n {\n range,\n n = range === undefined ? 5 : (range = [...range]).length,\n scheme = \"rdylbu\",\n domain = inferAutoDomain(key, channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n const [min, max] = extent(domain);\n let thresholds;\n if (range === undefined) {\n thresholds = ticks(min, max, n); // approximate number of nice, round thresholds\n if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound\n if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound\n n = thresholds.length + 1;\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n } else {\n thresholds = quantize(interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range\n if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types\n }\n if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain\n return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown});\n}\n\nexport function createScaleThreshold(\n key,\n channels,\n {\n domain = [0], // explicit thresholds in ascending order\n unknown,\n scheme = \"rdylbu\",\n interpolate,\n range = interpolate !== undefined\n ? quantize(interpolate, domain.length + 1)\n : registry.get(key) === color\n ? ordinalRange(scheme, domain.length + 1)\n : undefined,\n reverse\n }\n) {\n domain = arrayify(domain);\n const sign = orderof(domain); // preserve descending domain\n if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`);\n if (reverse) range = reverseof(range); // domain ascending, so reverse range\n return {\n type: \"threshold\",\n scale: scaleThreshold(sign < 0 ? reverseof(domain) : domain, range === undefined ? [] : range).unknown(unknown),\n domain,\n range\n };\n}\n\nfunction isOrdered(domain, sign) {\n for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) {\n const s = descending(d, (d = domain[i]));\n if (s !== 0 && s !== sign) return false;\n }\n return true;\n}\n\nexport function createScaleIdentity() {\n return {type: \"identity\", scale: scaleIdentity()};\n}\n\nexport function inferDomain(channels, f = finite) {\n return channels.length\n ? [\n min(channels, ({value}) => (value === undefined ? value : min(value, f))),\n max(channels, ({value}) => (value === undefined ? value : max(value, f)))\n ]\n : [0, 1];\n}\n\nfunction inferAutoDomain(key, channels) {\n const type = registry.get(key);\n return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain)(channels);\n}\n\nfunction inferZeroDomain(channels) {\n return [0, channels.length ? max(channels, ({value}) => (value === undefined ? value : max(value, finite))) : 1];\n}\n\n// We don’t want the upper bound of the radial domain to be zero, as this would\n// be degenerate, so we ignore nonpositive values. We also don’t want the\n// maximum default radius to exceed 30px.\nfunction inferRadialRange(channels, domain) {\n const hint = channels.find(({radius}) => radius !== undefined);\n if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins\n const h25 = quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : quantile(value, 0.25, positive)));\n const range = domain.map((d) => 3 * Math.sqrt(d / h25));\n const k = 30 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\n// We want a length scale’s domain to go from zero to a positive value, and to\n// treat negative lengths if any as inverted vectors of equivalent magnitude. We\n// also don’t want the maximum default length to exceed 60px.\nfunction inferLengthRange(channels, domain) {\n const h50 = median(channels, ({value}) => (value === undefined ? NaN : median(value, Math.abs)));\n const range = domain.map((d) => (12 * d) / h50);\n const k = 60 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\nfunction inferLogDomain(channels) {\n for (const {value} of channels) {\n if (value !== undefined) {\n for (let v of value) {\n if (v > 0) return inferDomain(channels, positive);\n if (v < 0) return inferDomain(channels, negative);\n }\n }\n }\n return [1, 10];\n}\n\nfunction inferQuantileDomain(channels) {\n const domain = [];\n for (const {value} of channels) {\n if (value === undefined) continue;\n for (const v of value) domain.push(v);\n }\n return domain;\n}\n\nexport function interpolatePiecewise(interpolate) {\n return (i, j) => (t) => interpolate(i + t * (j - i));\n}\n","import {\n descending,\n interpolateNumber,\n interpolateRgb,\n piecewise,\n scaleDiverging,\n scaleDivergingLog,\n scaleDivergingPow,\n scaleDivergingSymlog\n} from \"d3\";\nimport {positive, negative} from \"../defined.js\";\nimport {quantitativeScheme} from \"./schemes.js\";\nimport {registry, color} from \"./index.js\";\nimport {inferDomain, maybeInterpolator, flip, interpolatePiecewise} from \"./quantitative.js\";\n\nfunction createScaleD(\n key,\n scale,\n transform,\n channels,\n {\n type,\n nice,\n clamp,\n domain = inferDomain(channels),\n unknown,\n pivot = 0,\n scheme,\n range,\n symmetric = true,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : \"rdbu\")\n : interpolateNumber,\n reverse\n }\n) {\n pivot = +pivot;\n let [min, max] = domain;\n if (descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse);\n min = Math.min(min, pivot);\n max = Math.max(max, pivot);\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n\n // If an explicit range is specified, promote it to a piecewise interpolator.\n if (range !== undefined) {\n interpolate =\n interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : piecewise(interpolate, range);\n }\n\n // Reverse before normalization.\n if (reverse) interpolate = flip(interpolate);\n\n // Normalize the interpolator for symmetric difference around the pivot.\n if (symmetric) {\n const mid = transform.apply(pivot);\n const mindelta = mid - transform.apply(min);\n const maxdelta = transform.apply(max) - mid;\n if (mindelta < maxdelta) min = transform.invert(mid - maxdelta);\n else if (mindelta > maxdelta) max = transform.invert(mid + mindelta);\n }\n\n scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate);\n if (clamp) scale.clamp(clamp);\n if (nice) scale.nice(nice);\n return {type, domain: [min, max], pivot, interpolate, scale};\n}\n\nexport function createScaleDiverging(key, channels, options) {\n return createScaleD(key, scaleDiverging(), transformIdentity, channels, options);\n}\n\nexport function createScaleDivergingSqrt(key, channels, options) {\n return createScaleDivergingPow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) {\n return createScaleD(key, scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, {\n ...options,\n type: \"diverging-pow\"\n });\n}\n\nexport function createScaleDivergingLog(\n key,\n channels,\n {base = 10, pivot = 1, domain = inferDomain(channels, pivot < 0 ? negative : positive), ...options}\n) {\n return createScaleD(key, scaleDivergingLog().base((base = +base)), transformLog, channels, {\n domain,\n pivot,\n ...options\n });\n}\n\nexport function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleD(\n key,\n scaleDivergingSymlog().constant((constant = +constant)),\n transformSymlog(constant),\n channels,\n options\n );\n}\n\nconst transformIdentity = {\n apply(x) {\n return x;\n },\n invert(x) {\n return x;\n }\n};\n\nconst transformLog = {\n apply: Math.log,\n invert: Math.exp\n};\n\nconst transformSqrt = {\n apply(x) {\n return Math.sign(x) * Math.sqrt(Math.abs(x));\n },\n invert(x) {\n return Math.sign(x) * (x * x);\n }\n};\n\nfunction transformPow(exponent) {\n return exponent === 0.5\n ? transformSqrt\n : {\n apply(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), exponent);\n },\n invert(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent);\n }\n };\n}\n\nfunction transformSymlog(constant) {\n return {\n apply(x) {\n return Math.sign(x) * Math.log1p(Math.abs(x / constant));\n },\n invert(x) {\n return Math.sign(x) * Math.expm1(Math.abs(x)) * constant;\n }\n };\n}\n","import {scaleTime, scaleUtc} from \"d3\";\nimport {createScaleQ} from \"./quantitative.js\";\n\nfunction createScaleT(key, scale, channels, options) {\n return createScaleQ(key, scale, channels, options);\n}\n\nexport function createScaleTime(key, channels, options) {\n return createScaleT(key, scaleTime(), channels, options);\n}\n\nexport function createScaleUtc(key, channels, options) {\n return createScaleT(key, scaleUtc(), channels, options);\n}\n","import {InternSet, extent, quantize, reverse as reverseof, sort, symbolsFill, symbolsStroke} from \"d3\";\nimport {scaleBand, scaleOrdinal, scalePoint, scaleImplicit} from \"d3\";\nimport {ascendingDefined} from \"../defined.js\";\nimport {isNoneish, map, maybeRangeInterval} from \"../options.js\";\nimport {maybeSymbol} from \"../symbol.js\";\nimport {registry, color, position, symbol} from \"./index.js\";\nimport {maybeBooleanRange, ordinalScheme, quantitativeScheme} from \"./schemes.js\";\n\n// This denotes an implicitly ordinal color scale: the scale type was not set,\n// but the associated values are strings or booleans. If the associated defined\n// values are entirely boolean, the range will default to greys. You can opt out\n// of this by setting the type explicitly.\nexport const ordinalImplicit = Symbol(\"ordinal\");\n\nfunction createScaleO(key, scale, channels, {type, interval, domain, range, reverse, hint}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n if (type === \"categorical\" || type === ordinalImplicit) type = \"ordinal\"; // shorthand for color schemes\n if (reverse) domain = reverseof(domain);\n scale.domain(domain);\n if (range !== undefined) {\n // If the range is specified as a function, pass it the domain.\n if (typeof range === \"function\") range = range(domain);\n scale.range(range);\n }\n return {type, domain, range, scale, hint, interval};\n}\n\nexport function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n let hint;\n if (registry.get(key) === symbol) {\n hint = inferSymbolHint(channels);\n range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol);\n } else if (registry.get(key) === color) {\n if (range === undefined && (type === \"ordinal\" || type === ordinalImplicit)) {\n range = maybeBooleanRange(domain, scheme);\n if (range !== undefined) scheme = undefined; // Don’t re-apply scheme.\n }\n if (scheme === undefined && range === undefined) {\n scheme = type === \"ordinal\" ? \"turbo\" : \"tableau10\";\n }\n if (scheme !== undefined) {\n if (range !== undefined) {\n const interpolate = quantitativeScheme(scheme);\n const t0 = range[0],\n d = range[1] - range[0];\n range = ({length: n}) => quantize((t) => interpolate(t0 + d * t), n);\n } else {\n range = ordinalScheme(scheme);\n }\n }\n }\n if (unknown === scaleImplicit) {\n throw new Error(`implicit unknown on ${key} scale is not supported`);\n }\n return createScaleO(key, scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint});\n}\n\nexport function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) {\n return maybeRound(scalePoint().align(align).padding(padding), channels, options, key);\n}\n\nexport function createScaleBand(\n key,\n channels,\n {\n align = 0.5,\n padding = 0.1,\n paddingInner = padding,\n paddingOuter = key === \"fx\" || key === \"fy\" ? 0 : padding,\n ...options\n }\n) {\n return maybeRound(\n scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter),\n channels,\n options,\n key\n );\n}\n\nfunction maybeRound(scale, channels, options, key) {\n let {round} = options;\n if (round !== undefined) scale.round((round = !!round));\n scale = createScaleO(key, scale, channels, options);\n scale.round = round; // preserve for autoScaleRound\n return scale;\n}\n\nfunction inferDomain(channels, interval, key) {\n const values = new InternSet();\n for (const {value, domain} of channels) {\n if (domain !== undefined) return domain(); // see channelDomain\n if (value === undefined) continue;\n for (const v of value) values.add(v);\n }\n if (interval !== undefined) {\n const [min, max] = extent(values).map(interval.floor, interval);\n return interval.range(min, interval.offset(max));\n }\n if (values.size > 10e3 && registry.get(key) === position) {\n throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`);\n }\n return sort(values, ascendingDefined);\n}\n\n// If all channels provide a consistent hint, propagate it to the scale.\nfunction inferHint(channels, key) {\n let value;\n for (const {hint} of channels) {\n const candidate = hint?.[key];\n if (candidate === undefined) continue; // no hint here\n if (value === undefined) value = candidate;\n // first hint\n else if (value !== candidate) return; // inconsistent hint\n }\n return value;\n}\n\nfunction inferSymbolHint(channels) {\n return {\n fill: inferHint(channels, \"fill\"),\n stroke: inferHint(channels, \"stroke\")\n };\n}\n\nfunction inferSymbolRange(hint) {\n return isNoneish(hint.fill) ? symbolsStroke : symbolsFill;\n}\n","import {\n isOrdinal,\n isTemporal,\n isTemporalString,\n isNumericString,\n isScaleOptions,\n map,\n slice,\n coerceNumbers,\n coerceDates\n} from \"./options.js\";\nimport {registry, color, position, radius, opacity, symbol, length} from \"./scales/index.js\";\nimport {\n createScaleLinear,\n createScaleSqrt,\n createScalePow,\n createScaleLog,\n createScaleSymlog,\n createScaleQuantile,\n createScaleQuantize,\n createScaleThreshold,\n createScaleIdentity\n} from \"./scales/quantitative.js\";\nimport {\n createScaleDiverging,\n createScaleDivergingSqrt,\n createScaleDivergingPow,\n createScaleDivergingLog,\n createScaleDivergingSymlog\n} from \"./scales/diverging.js\";\nimport {isDivergingScheme} from \"./scales/schemes.js\";\nimport {createScaleTime, createScaleUtc} from \"./scales/temporal.js\";\nimport {createScaleOrdinal, createScalePoint, createScaleBand, ordinalImplicit} from \"./scales/ordinal.js\";\nimport {maybeSymbol} from \"./symbol.js\";\nimport {warn} from \"./warnings.js\";\n\nexport function createScales(\n channelsByScale,\n {\n label: globalLabel,\n inset: globalInset = 0,\n insetTop: globalInsetTop = globalInset,\n insetRight: globalInsetRight = globalInset,\n insetBottom: globalInsetBottom = globalInset,\n insetLeft: globalInsetLeft = globalInset,\n round,\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n facet: {label: facetLabel = globalLabel} = {},\n ...options\n } = {}\n) {\n const scales = {};\n for (const [key, channels] of channelsByScale) {\n const scaleOptions = options[key];\n const scale = createScale(key, channels, {\n round: registry.get(key) === position ? round : undefined, // only for position\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n ...scaleOptions\n });\n if (scale) {\n // populate generic scale options (percent, transform, insets)\n let {\n label = key === \"fx\" || key === \"fy\" ? facetLabel : globalLabel,\n percent,\n transform,\n inset,\n insetTop = inset !== undefined ? inset : key === \"y\" ? globalInsetTop : 0, // not fy\n insetRight = inset !== undefined ? inset : key === \"x\" ? globalInsetRight : 0, // not fx\n insetBottom = inset !== undefined ? inset : key === \"y\" ? globalInsetBottom : 0, // not fy\n insetLeft = inset !== undefined ? inset : key === \"x\" ? globalInsetLeft : 0 // not fx\n } = scaleOptions || {};\n if (transform == null) transform = undefined;\n else if (typeof transform !== \"function\") throw new Error(\"invalid scale transform; not a function\");\n scale.percent = !!percent;\n scale.label = label === undefined ? inferScaleLabel(channels, scale) : label;\n scale.transform = transform;\n if (key === \"x\" || key === \"fx\") {\n scale.insetLeft = +insetLeft;\n scale.insetRight = +insetRight;\n } else if (key === \"y\" || key === \"fy\") {\n scale.insetTop = +insetTop;\n scale.insetBottom = +insetBottom;\n }\n scales[key] = scale;\n }\n }\n return scales;\n}\n\nexport function createScaleFunctions(scales) {\n return Object.fromEntries(\n Object.entries(scales)\n .filter(([, {scale}]) => scale) // drop identity scales\n .map(([name, {scale, type, interval, label}]) => {\n scale.type = type; // for axis\n if (interval != null) scale.interval = interval; // for axis\n if (label != null) scale.label = label; // for axis\n return [name, scale];\n })\n );\n}\n\n// Mutates scale.range!\nexport function autoScaleRange(scales, dimensions) {\n const {x, y, fx, fy} = scales;\n const superdimensions = fx || fy ? outerDimensions(dimensions) : dimensions;\n if (fx) autoScaleRangeX(fx, superdimensions);\n if (fy) autoScaleRangeY(fy, superdimensions);\n const subdimensions = fx || fy ? innerDimensions(scales, dimensions) : dimensions;\n if (x) autoScaleRangeX(x, subdimensions);\n if (y) autoScaleRangeY(y, subdimensions);\n}\n\n// Channels can have labels; if all the channels for a given scale are\n// consistently labeled (i.e., have the same value if not undefined), and the\n// corresponding scale doesn’t already have an explicit label, then the\n// channels’ label is promoted to the scale. This inferred label should have an\n// orientation-appropriate arrow added when used as an axis, but we don’t want\n// to add the arrow when the label is set explicitly as an option; so, the\n// inferred label is distinguished as an object with an “inferred” property.\nfunction inferScaleLabel(channels = [], scale) {\n let label;\n for (const {label: l} of channels) {\n if (l === undefined) continue;\n if (label === undefined) label = l;\n else if (label !== l) return;\n }\n if (label === undefined) return;\n // Ignore the implicit label for temporal scales if it’s simply “date”.\n if (isTemporalScale(scale) && /^(date|time|year)$/i.test(label)) return;\n if (!isOrdinalScale(scale) && scale.percent) label = `${label} (%)`;\n return {inferred: true, toString: () => label};\n}\n\n// Returns the dimensions of the outer frame; this is subdivided into facets\n// with the margins of each facet collapsing into the outer margins.\nexport function outerDimensions(dimensions) {\n const {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width,\n height,\n facet: {\n marginTop: facetMarginTop,\n marginRight: facetMarginRight,\n marginBottom: facetMarginBottom,\n marginLeft: facetMarginLeft\n }\n } = dimensions;\n return {\n marginTop: Math.max(marginTop, facetMarginTop),\n marginRight: Math.max(marginRight, facetMarginRight),\n marginBottom: Math.max(marginBottom, facetMarginBottom),\n marginLeft: Math.max(marginLeft, facetMarginLeft),\n width,\n height\n };\n}\n\n// Returns the dimensions of each facet.\nexport function innerDimensions({fx, fy}, dimensions) {\n const {marginTop, marginRight, marginBottom, marginLeft, width, height} = outerDimensions(dimensions);\n return {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width: fx ? fx.scale.bandwidth() + marginLeft + marginRight : width,\n height: fy ? fy.scale.bandwidth() + marginTop + marginBottom : height\n };\n}\n\nfunction autoScaleRangeX(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetLeft, insetRight} = scale;\n const {width, marginLeft = 0, marginRight = 0} = dimensions;\n const left = marginLeft + insetLeft;\n const right = width - marginRight - insetRight;\n scale.range = [left, Math.max(left, right)];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRangeY(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetTop, insetBottom} = scale;\n const {height, marginTop = 0, marginBottom = 0} = dimensions;\n const top = marginTop + insetTop;\n const bottom = height - marginBottom - insetBottom;\n scale.range = [Math.max(top, bottom), top];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n else scale.range.reverse();\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRound(scale) {\n if (scale.round === undefined && isBandScale(scale) && roundError(scale) <= 30) {\n scale.scale.round(true);\n }\n}\n\n// If we were to turn on rounding for this band or point scale, how much wasted\n// space would it introduce (on both ends of the range)? This must match\n// d3.scaleBand’s rounding behavior:\n// https://github.com/d3/d3-scale/blob/83555bd759c7314420bd4240642beda5e258db9e/src/band.js#L20-L32\nfunction roundError({scale}) {\n const n = scale.domain().length;\n const [start, stop] = scale.range();\n const paddingInner = scale.paddingInner ? scale.paddingInner() : 1;\n const paddingOuter = scale.paddingOuter ? scale.paddingOuter() : scale.padding();\n const m = n - paddingInner;\n const step = Math.abs(stop - start) / Math.max(1, m + paddingOuter * 2);\n return (step - Math.floor(step)) * m;\n}\n\nfunction piecewiseRange(scale) {\n const length = scale.scale.domain().length + isThresholdScale(scale);\n if (!(length > 2)) return scale.range;\n const [start, end] = scale.range;\n return Array.from({length}, (_, i) => start + (i / (length - 1)) * (end - start));\n}\n\nexport function normalizeScale(key, scale, hint) {\n return createScale(key, hint === undefined ? undefined : [{hint}], {...scale});\n}\n\nfunction createScale(key, channels = [], options = {}) {\n const type = inferScaleType(key, channels, options);\n\n // Warn for common misuses of implicit ordinal scales. We disable this test if\n // you specify a scale interval or if you set the domain or range explicitly,\n // since setting the domain or range (typically with a cardinality of more than\n // two) is another indication that you intended for the scale to be ordinal; we\n // also disable it for facet scales since these are always band scales.\n if (\n options.type === undefined &&\n options.domain === undefined &&\n options.range === undefined &&\n options.interval == null &&\n key !== \"fx\" &&\n key !== \"fy\" &&\n isOrdinalScale({type})\n ) {\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isTemporal))\n warn(\n `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isTemporalString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isNumericString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a \"linear\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n }\n\n options.type = type; // Mutates input!\n\n // Once the scale type is known, coerce the associated channel values and any\n // explicitly-specified domain to the expected type.\n switch (type) {\n case \"diverging\":\n case \"diverging-sqrt\":\n case \"diverging-pow\":\n case \"diverging-log\":\n case \"diverging-symlog\":\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n case \"sqrt\":\n case \"threshold\":\n case \"quantile\":\n case \"pow\":\n case \"log\":\n case \"symlog\":\n options = coerceType(channels, options, coerceNumbers);\n break;\n case \"identity\":\n switch (registry.get(key)) {\n case position:\n options = coerceType(channels, options, coerceNumbers);\n break;\n case symbol:\n options = coerceType(channels, options, coerceSymbols);\n break;\n }\n break;\n case \"utc\":\n case \"time\":\n options = coerceType(channels, options, coerceDates);\n break;\n }\n\n switch (type) {\n case \"diverging\":\n return createScaleDiverging(key, channels, options);\n case \"diverging-sqrt\":\n return createScaleDivergingSqrt(key, channels, options);\n case \"diverging-pow\":\n return createScaleDivergingPow(key, channels, options);\n case \"diverging-log\":\n return createScaleDivergingLog(key, channels, options);\n case \"diverging-symlog\":\n return createScaleDivergingSymlog(key, channels, options);\n case \"categorical\":\n case \"ordinal\":\n case ordinalImplicit:\n return createScaleOrdinal(key, channels, options);\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n return createScaleLinear(key, channels, options);\n case \"sqrt\":\n return createScaleSqrt(key, channels, options);\n case \"threshold\":\n return createScaleThreshold(key, channels, options);\n case \"quantile\":\n return createScaleQuantile(key, channels, options);\n case \"quantize\":\n return createScaleQuantize(key, channels, options);\n case \"pow\":\n return createScalePow(key, channels, options);\n case \"log\":\n return createScaleLog(key, channels, options);\n case \"symlog\":\n return createScaleSymlog(key, channels, options);\n case \"utc\":\n return createScaleUtc(key, channels, options);\n case \"time\":\n return createScaleTime(key, channels, options);\n case \"point\":\n return createScalePoint(key, channels, options);\n case \"band\":\n return createScaleBand(key, channels, options);\n case \"identity\":\n return registry.get(key) === position ? createScaleIdentity() : {type: \"identity\"};\n case undefined:\n return;\n default:\n throw new Error(`unknown scale type: ${type}`);\n }\n}\n\nfunction formatScaleType(type) {\n return typeof type === \"symbol\" ? type.description : type;\n}\n\n// A special type symbol when the x and y scales are replaced with a projection.\nconst typeProjection = {toString: () => \"projection\"};\n\nfunction inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) {\n // The facet scales are always band scales; this cannot be changed.\n if (key === \"fx\" || key === \"fy\") return \"band\";\n\n // If a projection is specified, the x- and y-scales are disabled; these\n // channels will be projected rather than scaled. (But still check that none\n // of the associated channels are incompatible with a projection.)\n if ((key === \"x\" || key === \"y\") && projection != null) type = typeProjection;\n\n // If a channel dictates a scale type, make sure that it is consistent with\n // the user-specified scale type (if any) and all other channels. For example,\n // barY requires x to be a band scale and disallows any other scale type.\n for (const {type: t} of channels) {\n if (t === undefined) continue;\n else if (type === undefined) type = t;\n else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`);\n }\n\n // If the scale, a channel, or user specified a (consistent) type, return it.\n if (type === typeProjection) return;\n if (type !== undefined) return type;\n\n // If there’s no data (and no type) associated with this scale, don’t create a scale.\n if (domain === undefined && !channels.some(({value}) => value !== undefined)) return;\n\n // Some scales have default types.\n const kind = registry.get(key);\n if (kind === radius) return \"sqrt\";\n if (kind === opacity || kind === length) return \"linear\";\n if (kind === symbol) return \"ordinal\";\n\n // If the domain or range has more than two values, assume it’s ordinal. You\n // can still use a “piecewise” (or “polylinear”) scale, but you must set the\n // type explicitly.\n if ((domain || range || []).length > 2) return asOrdinalType(kind);\n\n // Otherwise, infer the scale type from the data! Prefer the domain, if\n // present, over channels. (The domain and channels should be consistently\n // typed, and the domain is more explicit and typically much smaller.) We only\n // check the first defined value for expedience and simplicity; we expect\n // that the types are consistent.\n if (domain !== undefined) {\n if (isOrdinal(domain)) return asOrdinalType(kind);\n if (isTemporal(domain)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n }\n\n // If any channel is ordinal or temporal, it takes priority.\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isOrdinal)) return asOrdinalType(kind);\n if (values.some(isTemporal)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n}\n\n// Positional scales default to a point scale instead of an ordinal scale.\nfunction asOrdinalType(kind) {\n switch (kind) {\n case position:\n return \"point\";\n case color:\n return ordinalImplicit;\n default:\n return \"ordinal\";\n }\n}\n\nexport function isTemporalScale({type}) {\n return type === \"time\" || type === \"utc\";\n}\n\nexport function isOrdinalScale({type}) {\n return type === \"ordinal\" || type === \"point\" || type === \"band\" || type === ordinalImplicit;\n}\n\nexport function isThresholdScale({type}) {\n return type === \"threshold\";\n}\n\nfunction isBandScale({type}) {\n return type === \"point\" || type === \"band\";\n}\n\nexport function isDivergingScale({type}) {\n return /^diverging($|-)/.test(type);\n}\n\n// Certain marks have special behavior if a scale is collapsed, i.e. if the\n// domain is degenerate and represents only a single value such as [3, 3]; for\n// example, a rect will span the full extent of the chart along a collapsed\n// dimension (whereas a dot will simply be drawn in the center).\nexport function isCollapsed(scale) {\n if (scale === undefined) return true; // treat missing scale as collapsed\n const domain = scale.domain();\n const value = scale(domain[0]);\n for (let i = 1, n = domain.length; i < n; ++i) {\n if (scale(domain[i]) - value) {\n return false;\n }\n }\n return true;\n}\n\n// Mutates channel.value!\nfunction coerceType(channels, {domain, ...options}, coerceValues) {\n for (const c of channels) {\n if (c.value !== undefined) {\n c.value = coerceValues(c.value);\n }\n }\n return {\n domain: domain === undefined ? domain : coerceValues(domain),\n ...options\n };\n}\n\nfunction coerceSymbols(values) {\n return map(values, maybeSymbol);\n}\n\nexport function scale(options = {}) {\n let scale;\n for (const key in options) {\n if (!registry.has(key)) continue; // ignore unknown properties\n if (!isScaleOptions(options[key])) continue; // e.g., ignore {color: \"red\"}\n if (scale !== undefined) throw new Error(\"ambiguous scale definition; multiple scales found\");\n scale = exposeScale(normalizeScale(key, options[key]));\n }\n if (scale === undefined) throw new Error(\"invalid scale definition; no scale found\");\n return scale;\n}\n\nexport function exposeScales(scaleDescriptors) {\n return (key) => {\n if (!registry.has((key = `${key}`))) throw new Error(`unknown scale: ${key}`);\n return key in scaleDescriptors ? exposeScale(scaleDescriptors[key]) : undefined;\n };\n}\n\n// Note: axis- and legend-related properties (such as label, ticks and\n// tickFormat) are not included here as they do not affect the scale’s behavior.\nfunction exposeScale({scale, type, domain, range, interpolate, interval, transform, percent, pivot}) {\n if (type === \"identity\") return {type: \"identity\", apply: (d) => d, invert: (d) => d};\n const unknown = scale.unknown ? scale.unknown() : undefined;\n return {\n type,\n domain: slice(domain), // defensive copy\n ...(range !== undefined && {range: slice(range)}), // defensive copy\n ...(transform !== undefined && {transform}),\n ...(percent && {percent}), // only exposed if truthy\n ...(unknown !== undefined && {unknown}),\n ...(interval !== undefined && {interval}),\n\n // quantitative\n ...(interpolate !== undefined && {interpolate}),\n ...(scale.clamp && {clamp: scale.clamp()}),\n\n // diverging (always asymmetric; we never want to apply the symmetric transform twice)\n ...(pivot !== undefined && {pivot, symmetric: false}),\n\n // log, diverging-log\n ...(scale.base && {base: scale.base()}),\n\n // pow, diverging-pow\n ...(scale.exponent && {exponent: scale.exponent()}),\n\n // symlog, diverging-symlog\n ...(scale.constant && {constant: scale.constant()}),\n\n // band, point\n ...(scale.align && {align: scale.align(), round: scale.round()}),\n ...(scale.padding &&\n (scale.paddingInner\n ? {paddingInner: scale.paddingInner(), paddingOuter: scale.paddingOuter()}\n : {padding: scale.padding()})),\n ...(scale.bandwidth && {bandwidth: scale.bandwidth(), step: scale.step()}),\n\n // utilities\n apply: (t) => scale(t),\n ...(scale.invert && {invert: (t) => scale.invert(t)})\n };\n}\n","import {format as isoFormat} from \"isoformat\";\nimport {string} from \"./options.js\";\nimport {memoize1} from \"./memoize.js\";\n\nconst numberFormat = memoize1((locale) => {\n return new Intl.NumberFormat(locale);\n});\n\nconst monthFormat = memoize1((locale, month) => {\n return new Intl.DateTimeFormat(locale, {timeZone: \"UTC\", ...(month && {month})});\n});\n\nconst weekdayFormat = memoize1((locale, weekday) => {\n return new Intl.DateTimeFormat(locale, {timeZone: \"UTC\", ...(weekday && {weekday})});\n});\n\nexport function formatNumber(locale = \"en-US\") {\n const format = numberFormat(locale);\n return (i) => (i != null && !isNaN(i) ? format.format(i) : undefined);\n}\n\nexport function formatMonth(locale = \"en-US\", format = \"short\") {\n const fmt = monthFormat(locale, format);\n return (i) => (i != null && !isNaN((i = +new Date(Date.UTC(2000, +i)))) ? fmt.format(i) : undefined);\n}\n\nexport function formatWeekday(locale = \"en-US\", format = \"short\") {\n const fmt = weekdayFormat(locale, format);\n return (i) => (i != null && !isNaN((i = +new Date(Date.UTC(2001, 0, +i)))) ? fmt.format(i) : undefined);\n}\n\nexport function formatIsoDate(date) {\n return isoFormat(date, \"Invalid Date\");\n}\n\nexport function formatAuto(locale = \"en-US\") {\n const number = formatNumber(locale);\n return (v) => (v instanceof Date ? formatIsoDate : typeof v === \"number\" ? number : string)(v);\n}\n\n// TODO When Plot supports a top-level locale option, this should be removed\n// because it lacks context to know which locale to use; formatAuto should be\n// used instead whenever possible.\nexport const formatDefault = formatAuto();\n","export function memoize1(compute) {\n let cacheValue, cacheKeys;\n return (...keys) => {\n if (cacheKeys?.length !== keys.length || cacheKeys.some((k, i) => k !== keys[i])) {\n cacheKeys = keys;\n cacheValue = compute(...keys);\n }\n return cacheValue;\n };\n}\n","import {geoPath, group, namespaces} from \"d3\";\nimport {create} from \"./context.js\";\nimport {defined, nonempty} from \"./defined.js\";\nimport {formatDefault} from \"./format.js\";\nimport {\n string,\n number,\n maybeColorChannel,\n maybeNumberChannel,\n maybeKeyword,\n isNoneish,\n isNone,\n isRound,\n keyof\n} from \"./options.js\";\nimport {warn} from \"./warnings.js\";\n\nexport const offset = (typeof window !== \"undefined\" ? window.devicePixelRatio > 1 : typeof it === \"undefined\") ? 0 : 0.5; // prettier-ignore\n\nlet nextClipId = 0;\n\nfunction getClipId() {\n return `plot-clip-${++nextClipId}`;\n}\n\nexport function styles(\n mark,\n {\n title,\n href,\n ariaLabel: variaLabel,\n ariaDescription,\n ariaHidden,\n target,\n fill,\n fillOpacity,\n stroke,\n strokeWidth,\n strokeOpacity,\n strokeLinejoin,\n strokeLinecap,\n strokeMiterlimit,\n strokeDasharray,\n strokeDashoffset,\n opacity,\n mixBlendMode,\n paintOrder,\n pointerEvents,\n shapeRendering\n },\n {\n ariaLabel: cariaLabel,\n fill: defaultFill = \"currentColor\",\n fillOpacity: defaultFillOpacity,\n stroke: defaultStroke = \"none\",\n strokeOpacity: defaultStrokeOpacity,\n strokeWidth: defaultStrokeWidth,\n strokeLinecap: defaultStrokeLinecap,\n strokeLinejoin: defaultStrokeLinejoin,\n strokeMiterlimit: defaultStrokeMiterlimit,\n paintOrder: defaultPaintOrder\n }\n) {\n // Some marks don’t support fill (e.g., tick and rule).\n if (defaultFill === null) {\n fill = null;\n fillOpacity = null;\n }\n\n // Some marks don’t support stroke (e.g., image).\n if (defaultStroke === null) {\n stroke = null;\n strokeOpacity = null;\n }\n\n // Some marks default to fill with no stroke, while others default to stroke\n // with no fill. For example, bar and area default to fill, while dot and line\n // default to stroke. For marks that fill by default, the default fill only\n // applies if the stroke is (constant) none; if you set a stroke, then the\n // default fill becomes none. Similarly for marks that stroke by stroke, the\n // default stroke only applies if the fill is (constant) none.\n if (isNoneish(defaultFill)) {\n if (!isNoneish(defaultStroke) && !isNoneish(fill)) defaultStroke = \"none\";\n } else {\n if (isNoneish(defaultStroke) && !isNoneish(stroke)) defaultFill = \"none\";\n }\n\n const [vfill, cfill] = maybeColorChannel(fill, defaultFill);\n const [vfillOpacity, cfillOpacity] = maybeNumberChannel(fillOpacity, defaultFillOpacity);\n const [vstroke, cstroke] = maybeColorChannel(stroke, defaultStroke);\n const [vstrokeOpacity, cstrokeOpacity] = maybeNumberChannel(strokeOpacity, defaultStrokeOpacity);\n const [vopacity, copacity] = maybeNumberChannel(opacity);\n\n // For styles that have no effect if there is no stroke, only apply the\n // defaults if the stroke is not the constant none. (If stroke is a channel,\n // then cstroke will be undefined, but there’s still a stroke; hence we don’t\n // use isNoneish here.)\n if (!isNone(cstroke)) {\n if (strokeWidth === undefined) strokeWidth = defaultStrokeWidth;\n if (strokeLinecap === undefined) strokeLinecap = defaultStrokeLinecap;\n if (strokeLinejoin === undefined) strokeLinejoin = defaultStrokeLinejoin;\n\n // The default stroke miterlimit need not be applied if the current stroke\n // is the constant round; this only has effect on miter joins.\n if (strokeMiterlimit === undefined && !isRound(strokeLinejoin)) strokeMiterlimit = defaultStrokeMiterlimit;\n\n // The paint order only takes effect if there is both a fill and a stroke\n // (at least if we ignore markers, which no built-in marks currently use).\n if (!isNone(cfill) && paintOrder === undefined) paintOrder = defaultPaintOrder;\n }\n\n const [vstrokeWidth, cstrokeWidth] = maybeNumberChannel(strokeWidth);\n\n // Some marks don’t support fill (e.g., tick and rule).\n if (defaultFill !== null) {\n mark.fill = impliedString(cfill, \"currentColor\");\n mark.fillOpacity = impliedNumber(cfillOpacity, 1);\n }\n\n // Some marks don’t support stroke (e.g., image).\n if (defaultStroke !== null) {\n mark.stroke = impliedString(cstroke, \"none\");\n mark.strokeWidth = impliedNumber(cstrokeWidth, 1);\n mark.strokeOpacity = impliedNumber(cstrokeOpacity, 1);\n mark.strokeLinejoin = impliedString(strokeLinejoin, \"miter\");\n mark.strokeLinecap = impliedString(strokeLinecap, \"butt\");\n mark.strokeMiterlimit = impliedNumber(strokeMiterlimit, 4);\n mark.strokeDasharray = impliedString(strokeDasharray, \"none\");\n mark.strokeDashoffset = impliedString(strokeDashoffset, \"0\");\n }\n\n mark.target = string(target);\n mark.ariaLabel = string(cariaLabel);\n mark.ariaDescription = string(ariaDescription);\n mark.ariaHidden = string(ariaHidden);\n mark.opacity = impliedNumber(copacity, 1);\n mark.mixBlendMode = impliedString(mixBlendMode, \"normal\");\n mark.paintOrder = impliedString(paintOrder, \"normal\");\n mark.pointerEvents = impliedString(pointerEvents, \"auto\");\n mark.shapeRendering = impliedString(shapeRendering, \"auto\");\n\n return {\n title: {value: title, optional: true},\n href: {value: href, optional: true},\n ariaLabel: {value: variaLabel, optional: true},\n fill: {value: vfill, scale: \"auto\", optional: true},\n fillOpacity: {value: vfillOpacity, scale: \"auto\", optional: true},\n stroke: {value: vstroke, scale: \"auto\", optional: true},\n strokeOpacity: {value: vstrokeOpacity, scale: \"auto\", optional: true},\n strokeWidth: {value: vstrokeWidth, optional: true},\n opacity: {value: vopacity, scale: \"auto\", optional: true}\n };\n}\n\n// Applies the specified titles via selection.call.\nexport function applyTitle(selection, L) {\n if (L)\n selection\n .filter((i) => nonempty(L[i]))\n .append(\"title\")\n .call(applyText, L);\n}\n\n// Like applyTitle, but for grouped data (lines, areas).\nexport function applyTitleGroup(selection, L) {\n if (L)\n selection\n .filter(([i]) => nonempty(L[i]))\n .append(\"title\")\n .call(applyTextGroup, L);\n}\n\nexport function applyText(selection, T) {\n if (T) selection.text((i) => formatDefault(T[i]));\n}\n\nexport function applyTextGroup(selection, T) {\n if (T) selection.text(([i]) => formatDefault(T[i]));\n}\n\nexport function applyChannelStyles(\n selection,\n {target},\n {\n ariaLabel: AL,\n title: T,\n fill: F,\n fillOpacity: FO,\n stroke: S,\n strokeOpacity: SO,\n strokeWidth: SW,\n opacity: O,\n href: H\n }\n) {\n if (AL) applyAttr(selection, \"aria-label\", (i) => AL[i]);\n if (F) applyAttr(selection, \"fill\", (i) => F[i]);\n if (FO) applyAttr(selection, \"fill-opacity\", (i) => FO[i]);\n if (S) applyAttr(selection, \"stroke\", (i) => S[i]);\n if (SO) applyAttr(selection, \"stroke-opacity\", (i) => SO[i]);\n if (SW) applyAttr(selection, \"stroke-width\", (i) => SW[i]);\n if (O) applyAttr(selection, \"opacity\", (i) => O[i]);\n if (H) applyHref(selection, (i) => H[i], target);\n applyTitle(selection, T);\n}\n\nexport function applyGroupedChannelStyles(\n selection,\n {target},\n {\n ariaLabel: AL,\n title: T,\n fill: F,\n fillOpacity: FO,\n stroke: S,\n strokeOpacity: SO,\n strokeWidth: SW,\n opacity: O,\n href: H\n }\n) {\n if (AL) applyAttr(selection, \"aria-label\", ([i]) => AL[i]);\n if (F) applyAttr(selection, \"fill\", ([i]) => F[i]);\n if (FO) applyAttr(selection, \"fill-opacity\", ([i]) => FO[i]);\n if (S) applyAttr(selection, \"stroke\", ([i]) => S[i]);\n if (SO) applyAttr(selection, \"stroke-opacity\", ([i]) => SO[i]);\n if (SW) applyAttr(selection, \"stroke-width\", ([i]) => SW[i]);\n if (O) applyAttr(selection, \"opacity\", ([i]) => O[i]);\n if (H) applyHref(selection, ([i]) => H[i], target);\n applyTitleGroup(selection, T);\n}\n\nfunction groupAesthetics({\n ariaLabel: AL,\n title: T,\n fill: F,\n fillOpacity: FO,\n stroke: S,\n strokeOpacity: SO,\n strokeWidth: SW,\n opacity: O,\n href: H\n}) {\n return [AL, T, F, FO, S, SO, SW, O, H].filter((c) => c !== undefined);\n}\n\nexport function groupZ(I, Z, z) {\n const G = group(I, (i) => Z[i]);\n if (z === undefined && G.size > I.length >> 1) {\n warn(\n `Warning: the implicit z channel has high cardinality. This may occur when the fill or stroke channel is associated with quantitative data rather than ordinal or categorical data. You can suppress this warning by setting the z option explicitly; if this data represents a single series, set z to null.`\n );\n }\n return G.values();\n}\n\nexport function* groupIndex(I, position, {z}, channels) {\n const {z: Z} = channels; // group channel\n const A = groupAesthetics(channels); // aesthetic channels\n const C = [...position, ...A]; // all channels\n\n // Group the current index by Z (if any).\n for (const G of Z ? groupZ(I, Z, z) : [I]) {\n let Ag; // the A-values (aesthetics) of the current group, if any\n let Gg; // the current group index (a subset of G, and I), if any\n out: for (const i of G) {\n // If any channel has an undefined value for this index, skip it.\n for (const c of C) {\n if (!defined(c[i])) {\n if (Gg) Gg.push(-1);\n continue out;\n }\n }\n\n // Otherwise, if this is a new group, record the aesthetics for this\n // group. Yield the current group and start a new one.\n if (Ag === undefined) {\n if (Gg) yield Gg;\n (Ag = A.map((c) => keyof(c[i]))), (Gg = [i]);\n continue;\n }\n\n // Otherwise, add the current index to the current group. Then, if any of\n // the aesthetics don’t match the current group, yield the current group\n // and start a new group of the current index.\n Gg.push(i);\n for (let j = 0; j < A.length; ++j) {\n const k = keyof(A[j][i]);\n if (k !== Ag[j]) {\n yield Gg;\n (Ag = A.map((c) => keyof(c[i]))), (Gg = [i]);\n continue out;\n }\n }\n }\n\n // Yield the current group, if any.\n if (Gg) yield Gg;\n }\n}\n\n// TODO Accept other types of clips (paths, urls, x, y, other marks…)?\n// https://github.com/observablehq/plot/issues/181\nexport function maybeClip(clip) {\n if (clip === true) clip = \"frame\";\n else if (clip === false) clip = null;\n return maybeKeyword(clip, \"clip\", [\"frame\", \"sphere\"]);\n}\n\n// Note: may mutate selection.node!\nfunction applyClip(selection, mark, dimensions, context) {\n let clipUrl;\n switch (mark.clip) {\n case \"frame\": {\n const {width, height, marginLeft, marginRight, marginTop, marginBottom} = dimensions;\n const id = getClipId();\n clipUrl = `url(#${id})`;\n selection = create(\"svg:g\", context)\n .call((g) =>\n g\n .append(\"svg:clipPath\")\n .attr(\"id\", id)\n .append(\"rect\")\n .attr(\"x\", marginLeft)\n .attr(\"y\", marginTop)\n .attr(\"width\", width - marginRight - marginLeft)\n .attr(\"height\", height - marginTop - marginBottom)\n )\n .each(function () {\n this.appendChild(selection.node());\n selection.node = () => this; // Note: mutation!\n });\n break;\n }\n case \"sphere\": {\n const {projection} = context;\n if (!projection) throw new Error(`the \"sphere\" clip option requires a projection`);\n const id = getClipId();\n clipUrl = `url(#${id})`;\n selection\n .append(\"clipPath\")\n .attr(\"id\", id)\n .append(\"path\")\n .attr(\"d\", geoPath(projection)({type: \"Sphere\"}));\n break;\n }\n }\n // Here we’re careful to apply the ARIA attributes to the outer G element when\n // clipping is applied, and to apply the ARIA attributes before any other\n // attributes (for readability).\n applyAttr(selection, \"aria-label\", mark.ariaLabel);\n applyAttr(selection, \"aria-description\", mark.ariaDescription);\n applyAttr(selection, \"aria-hidden\", mark.ariaHidden);\n applyAttr(selection, \"clip-path\", clipUrl);\n}\n\n// Note: may mutate selection.node!\nexport function applyIndirectStyles(selection, mark, dimensions, context) {\n applyClip(selection, mark, dimensions, context);\n applyAttr(selection, \"fill\", mark.fill);\n applyAttr(selection, \"fill-opacity\", mark.fillOpacity);\n applyAttr(selection, \"stroke\", mark.stroke);\n applyAttr(selection, \"stroke-width\", mark.strokeWidth);\n applyAttr(selection, \"stroke-opacity\", mark.strokeOpacity);\n applyAttr(selection, \"stroke-linejoin\", mark.strokeLinejoin);\n applyAttr(selection, \"stroke-linecap\", mark.strokeLinecap);\n applyAttr(selection, \"stroke-miterlimit\", mark.strokeMiterlimit);\n applyAttr(selection, \"stroke-dasharray\", mark.strokeDasharray);\n applyAttr(selection, \"stroke-dashoffset\", mark.strokeDashoffset);\n applyAttr(selection, \"shape-rendering\", mark.shapeRendering);\n applyAttr(selection, \"paint-order\", mark.paintOrder);\n applyAttr(selection, \"pointer-events\", mark.pointerEvents);\n}\n\nexport function applyDirectStyles(selection, mark) {\n applyStyle(selection, \"mix-blend-mode\", mark.mixBlendMode);\n applyAttr(selection, \"opacity\", mark.opacity);\n}\n\nfunction applyHref(selection, href, target) {\n selection.each(function (i) {\n const h = href(i);\n if (h != null) {\n const a = this.ownerDocument.createElementNS(namespaces.svg, \"a\");\n a.setAttribute(\"fill\", \"inherit\");\n a.setAttributeNS(namespaces.xlink, \"href\", h);\n if (target != null) a.setAttribute(\"target\", target);\n this.parentNode.insertBefore(a, this).appendChild(this);\n }\n });\n}\n\nexport function applyAttr(selection, name, value) {\n if (value != null) selection.attr(name, value);\n}\n\nexport function applyStyle(selection, name, value) {\n if (value != null) selection.style(name, value);\n}\n\nexport function applyTransform(selection, mark, {x, y}, tx = offset, ty = offset) {\n tx += mark.dx;\n ty += mark.dy;\n if (x?.bandwidth) tx += x.bandwidth() / 2;\n if (y?.bandwidth) ty += y.bandwidth() / 2;\n if (tx || ty) selection.attr(\"transform\", `translate(${tx},${ty})`);\n}\n\nexport function impliedString(value, impliedValue) {\n if ((value = string(value)) !== impliedValue) return value;\n}\n\nexport function impliedNumber(value, impliedValue) {\n if ((value = number(value)) !== impliedValue) return value;\n}\n\n// https://www.w3.org/TR/CSS21/grammar.html\nconst validClassName =\n /^-?([_a-z]|[\\240-\\377]|\\\\[0-9a-f]{1,6}(\\r\\n|[ \\t\\r\\n\\f])?|\\\\[^\\r\\n\\f0-9a-f])([_a-z0-9-]|[\\240-\\377]|\\\\[0-9a-f]{1,6}(\\r\\n|[ \\t\\r\\n\\f])?|\\\\[^\\r\\n\\f0-9a-f])*$/i;\n\nexport function maybeClassName(name) {\n // The default should be changed whenever the default styles are changed, so\n // as to avoid conflict when multiple versions of Plot are on the page.\n if (name === undefined) return \"plot-d6a7b5\";\n name = `${name}`;\n if (!validClassName.test(name)) throw new Error(`invalid class name: ${name}`);\n return name;\n}\n\nexport function applyInlineStyles(selection, style) {\n if (typeof style === \"string\") {\n selection.property(\"style\", style);\n } else if (style != null) {\n for (const element of selection) {\n Object.assign(element.style, style);\n }\n }\n}\n\nexport function applyFrameAnchor({frameAnchor}, {width, height, marginTop, marginRight, marginBottom, marginLeft}) {\n return [\n /left$/.test(frameAnchor)\n ? marginLeft\n : /right$/.test(frameAnchor)\n ? width - marginRight\n : (marginLeft + width - marginRight) / 2,\n /^top/.test(frameAnchor)\n ? marginTop\n : /^bottom/.test(frameAnchor)\n ? height - marginBottom\n : (marginTop + height - marginBottom) / 2\n ];\n}\n","import {format, utcFormat} from \"d3\";\nimport {formatIsoDate} from \"./format.js\";\nimport {constant, isTemporal, string} from \"./options.js\";\nimport {isOrdinalScale} from \"./scales.js\";\n\nexport function inferFontVariant(scale) {\n return isOrdinalScale(scale) && scale.interval === undefined ? undefined : \"tabular-nums\";\n}\n\n// D3 doesn’t provide a tick format for ordinal scales; we want shorthand when\n// an ordinal domain is numbers or dates, and we want null to mean the empty\n// string, not the default identity format. TODO Remove this in favor of the\n// axis mark’s inferTickFormat.\nexport function maybeAutoTickFormat(tickFormat, domain) {\n return tickFormat === undefined\n ? isTemporal(domain)\n ? formatIsoDate\n : string\n : typeof tickFormat === \"function\"\n ? tickFormat\n : (typeof tickFormat === \"string\" ? (isTemporal(domain) ? utcFormat : format) : constant)(tickFormat);\n}\n","import {pathRound as path} from \"d3\";\nimport {inferFontVariant, maybeAutoTickFormat} from \"../axes.js\";\nimport {createContext, create} from \"../context.js\";\nimport {isNoneish, maybeColorChannel, maybeNumberChannel} from \"../options.js\";\nimport {isOrdinalScale, isThresholdScale} from \"../scales.js\";\nimport {applyInlineStyles, impliedString, maybeClassName} from \"../style.js\";\n\nfunction maybeScale(scale, key) {\n if (key == null) return key;\n const s = scale(key);\n if (!s) throw new Error(`scale not found: ${key}`);\n return s;\n}\n\nexport function legendSwatches(color, {opacity, ...options} = {}) {\n if (!isOrdinalScale(color) && !isThresholdScale(color))\n throw new Error(`swatches legend requires ordinal or threshold color scale (not ${color.type})`);\n return legendItems(color, options, (selection, scale, width, height) =>\n selection\n .append(\"svg\")\n .attr(\"width\", width)\n .attr(\"height\", height)\n .attr(\"fill\", scale.scale)\n .attr(\"fill-opacity\", maybeNumberChannel(opacity)[1])\n .append(\"rect\")\n .attr(\"width\", \"100%\")\n .attr(\"height\", \"100%\")\n );\n}\n\nexport function legendSymbols(\n symbol,\n {\n fill = symbol.hint?.fill !== undefined ? symbol.hint.fill : \"none\",\n fillOpacity = 1,\n stroke = symbol.hint?.stroke !== undefined ? symbol.hint.stroke : isNoneish(fill) ? \"currentColor\" : \"none\",\n strokeOpacity = 1,\n strokeWidth = 1.5,\n r = 4.5,\n ...options\n } = {},\n scale\n) {\n const [vf, cf] = maybeColorChannel(fill);\n const [vs, cs] = maybeColorChannel(stroke);\n const sf = maybeScale(scale, vf);\n const ss = maybeScale(scale, vs);\n const size = r * r * Math.PI;\n fillOpacity = maybeNumberChannel(fillOpacity)[1];\n strokeOpacity = maybeNumberChannel(strokeOpacity)[1];\n strokeWidth = maybeNumberChannel(strokeWidth)[1];\n return legendItems(symbol, options, (selection, scale, width, height) =>\n selection\n .append(\"svg\")\n .attr(\"viewBox\", \"-8 -8 16 16\")\n .attr(\"width\", width)\n .attr(\"height\", height)\n .attr(\"fill\", vf === \"color\" ? (d) => sf.scale(d) : cf)\n .attr(\"fill-opacity\", fillOpacity)\n .attr(\"stroke\", vs === \"color\" ? (d) => ss.scale(d) : cs)\n .attr(\"stroke-opacity\", strokeOpacity)\n .attr(\"stroke-width\", strokeWidth)\n .append(\"path\")\n .attr(\"d\", (d) => {\n const p = path();\n symbol.scale(d).draw(p, size);\n return p;\n })\n );\n}\n\nfunction legendItems(scale, options = {}, swatch) {\n let {\n columns,\n tickFormat,\n fontVariant = inferFontVariant(scale),\n // TODO label,\n swatchSize = 15,\n swatchWidth = swatchSize,\n swatchHeight = swatchSize,\n marginLeft = 0,\n className,\n style,\n width\n } = options;\n const context = createContext(options);\n className = maybeClassName(className);\n tickFormat = maybeAutoTickFormat(tickFormat, scale.domain);\n\n const swatches = create(\"div\", context).attr(\n \"class\",\n `${className}-swatches ${className}-swatches-${columns != null ? \"columns\" : \"wrap\"}`\n );\n\n let extraStyle;\n\n if (columns != null) {\n extraStyle = `.${className}-swatches-columns .${className}-swatch {\n display: flex;\n align-items: center;\n break-inside: avoid;\n padding-bottom: 1px;\n}\n.${className}-swatches-columns .${className}-swatch::before {\n flex-shrink: 0;\n}\n.${className}-swatches-columns .${className}-swatch-label {\n white-space: nowrap;\n overflow: hidden;\n text-overflow: ellipsis;\n}`;\n\n swatches\n .style(\"columns\", columns)\n .selectAll()\n .data(scale.domain)\n .enter()\n .append(\"div\")\n .attr(\"class\", `${className}-swatch`)\n .call(swatch, scale, swatchWidth, swatchHeight)\n .call((item) =>\n item.append(\"div\").attr(\"class\", `${className}-swatch-label`).attr(\"title\", tickFormat).text(tickFormat)\n );\n } else {\n extraStyle = `.${className}-swatches-wrap {\n display: flex;\n align-items: center;\n min-height: 33px;\n flex-wrap: wrap;\n}\n.${className}-swatches-wrap .${className}-swatch {\n display: inline-flex;\n align-items: center;\n margin-right: 1em;\n}`;\n\n swatches\n .selectAll()\n .data(scale.domain)\n .enter()\n .append(\"span\")\n .attr(\"class\", `${className}-swatch`)\n .call(swatch, scale, swatchWidth, swatchHeight)\n .append(function () {\n return this.ownerDocument.createTextNode(tickFormat.apply(this, arguments));\n });\n }\n\n return swatches\n .call((div) =>\n div.insert(\"style\", \"*\").text(\n `.${className}-swatches {\n font-family: system-ui, sans-serif;\n font-size: 10px;\n margin-bottom: 0.5em;\n}\n.${className}-swatch > svg {\n margin-right: 0.5em;\n overflow: visible;\n}\n${extraStyle}`\n )\n )\n .style(\"margin-left\", marginLeft ? `${+marginLeft}px` : null)\n .style(\"width\", width === undefined ? null : `${+width}px`)\n .style(\"font-variant\", impliedString(fontVariant, \"normal\"))\n .call(applyInlineStyles, style)\n .node();\n}\n","import {rgb} from \"d3\";\nimport {createContext} from \"./context.js\";\nimport {legendRamp} from \"./legends/ramp.js\";\nimport {legendSwatches, legendSymbols} from \"./legends/swatches.js\";\nimport {inherit, isScaleOptions} from \"./options.js\";\nimport {normalizeScale} from \"./scales.js\";\n\nconst legendRegistry = new Map([\n [\"symbol\", legendSymbols],\n [\"color\", legendColor],\n [\"opacity\", legendOpacity]\n]);\n\nexport function legend(options = {}) {\n for (const [key, value] of legendRegistry) {\n const scale = options[key];\n if (isScaleOptions(scale)) {\n // e.g., ignore {color: \"red\"}\n const context = createContext(options);\n let hint;\n // For symbol legends, pass a hint to the symbol scale.\n if (key === \"symbol\") {\n const {fill, stroke = fill === undefined && isScaleOptions(options.color) ? \"color\" : undefined} = options;\n hint = {fill, stroke};\n }\n return value(normalizeScale(key, scale, hint), legendOptions(context, scale, options), (key) =>\n isScaleOptions(options[key]) ? normalizeScale(key, options[key]) : null\n );\n }\n }\n throw new Error(\"unknown legend type; no scale found\");\n}\n\nexport function exposeLegends(scales, context, defaults = {}) {\n return (key, options) => {\n if (!legendRegistry.has(key)) throw new Error(`unknown legend type: ${key}`);\n if (!(key in scales)) return;\n return legendRegistry.get(key)(scales[key], legendOptions(context, defaults[key], options), (key) => scales[key]);\n };\n}\n\nfunction legendOptions({className, ...context}, {label, ticks, tickFormat} = {}, options) {\n return inherit(options, {className, ...context}, {label, ticks, tickFormat});\n}\n\nfunction legendColor(color, {legend = true, ...options}) {\n if (legend === true) legend = color.type === \"ordinal\" ? \"swatches\" : \"ramp\";\n if (color.domain === undefined) return;\n switch (`${legend}`.toLowerCase()) {\n case \"swatches\":\n return legendSwatches(color, options);\n case \"ramp\":\n return legendRamp(color, options);\n default:\n throw new Error(`unknown legend type: ${legend}`);\n }\n}\n\nfunction legendOpacity({type, interpolate, ...scale}, {legend = true, color = rgb(0, 0, 0), ...options}) {\n if (!interpolate) throw new Error(`${type} opacity scales are not supported`);\n if (legend === true) legend = \"ramp\";\n if (`${legend}`.toLowerCase() !== \"ramp\") throw new Error(`${legend} opacity legends are not supported`);\n return legendColor({type, ...scale, interpolate: interpolateOpacity(color)}, {legend, ...options});\n}\n\nfunction interpolateOpacity(color) {\n const {r, g, b} = rgb(color) || rgb(0, 0, 0); // treat invalid color as black\n return (t) => `rgba(${r},${g},${b},${t})`;\n}\n\nexport function createLegends(scales, context, options) {\n const legends = [];\n for (const [key, value] of legendRegistry) {\n const o = options[key];\n if (o?.legend && key in scales) {\n const legend = value(scales[key], legendOptions(context, scales[key], o), (key) => scales[key]);\n if (legend != null) legends.push(legend);\n }\n }\n return legends;\n}\n","import {quantize, interpolateNumber, piecewise, format, scaleBand, scaleLinear, axisBottom} from \"d3\";\nimport {inferFontVariant} from \"../axes.js\";\nimport {createContext, create} from \"../context.js\";\nimport {map, maybeNumberChannel} from \"../options.js\";\nimport {interpolatePiecewise} from \"../scales/quantitative.js\";\nimport {applyInlineStyles, impliedString, maybeClassName} from \"../style.js\";\n\nexport function legendRamp(color, options) {\n let {\n label = color.label,\n tickSize = 6,\n width = 240,\n height = 44 + tickSize,\n marginTop = 18,\n marginRight = 0,\n marginBottom = 16 + tickSize,\n marginLeft = 0,\n style,\n ticks = (width - marginLeft - marginRight) / 64,\n tickFormat,\n fontVariant = inferFontVariant(color),\n round = true,\n opacity,\n className\n } = options;\n const context = createContext(options);\n className = maybeClassName(className);\n opacity = maybeNumberChannel(opacity)[1];\n if (tickFormat === null) tickFormat = () => null;\n\n const svg = create(\"svg\", context)\n .attr(\"class\", `${className}-ramp`)\n .attr(\"font-family\", \"system-ui, sans-serif\")\n .attr(\"font-size\", 10)\n .attr(\"width\", width)\n .attr(\"height\", height)\n .attr(\"viewBox\", `0 0 ${width} ${height}`)\n .call((svg) =>\n // Warning: if you edit this, change defaultClassName.\n svg.append(\"style\").text(\n `.${className}-ramp {\n display: block;\n background: white;\n height: auto;\n height: intrinsic;\n max-width: 100%;\n overflow: visible;\n}\n.${className}-ramp text {\n white-space: pre;\n}`\n )\n )\n .call(applyInlineStyles, style);\n\n let tickAdjust = (g) => g.selectAll(\".tick line\").attr(\"y1\", marginTop + marginBottom - height);\n\n let x;\n\n // Some D3 scales use scale.interpolate, some scale.interpolator, and some\n // scale.round; this normalizes the API so it works with all scale types.\n const applyRange = round ? (x, range) => x.rangeRound(range) : (x, range) => x.range(range);\n\n const {type, domain, range, interpolate, scale, pivot} = color;\n\n // Continuous\n if (interpolate) {\n // Often interpolate is a “fixed” interpolator on the [0, 1] interval, as\n // with a built-in color scheme, but sometimes it is a function that takes\n // two arguments and is used in conjunction with the range.\n const interpolator =\n range === undefined\n ? interpolate\n : piecewise(interpolate.length === 1 ? interpolatePiecewise(interpolate) : interpolate, range);\n\n // Construct a D3 scale of the same type, but with a range that evenly\n // divides the horizontal extent of the legend. (In the common case, the\n // domain.length is two, and so the range is simply the extent.) For a\n // diverging scale, we need an extra point in the range for the pivot such\n // that the pivot is always drawn in the middle.\n x = applyRange(\n scale.copy(),\n quantize(\n interpolateNumber(marginLeft, width - marginRight),\n Math.min(domain.length + (pivot !== undefined), range === undefined ? Infinity : range.length)\n )\n );\n\n // Construct a 256×1 canvas, filling each pixel using the interpolator.\n const n = 256;\n const canvas = context.document.createElement(\"canvas\");\n canvas.width = n;\n canvas.height = 1;\n const context2 = canvas.getContext(\"2d\");\n for (let i = 0, j = n - 1; i < n; ++i) {\n context2.fillStyle = interpolator(i / j);\n context2.fillRect(i, 0, 1, 1);\n }\n\n svg\n .append(\"image\")\n .attr(\"opacity\", opacity)\n .attr(\"x\", marginLeft)\n .attr(\"y\", marginTop)\n .attr(\"width\", width - marginLeft - marginRight)\n .attr(\"height\", height - marginTop - marginBottom)\n .attr(\"preserveAspectRatio\", \"none\")\n .attr(\"xlink:href\", canvas.toDataURL());\n }\n\n // Threshold\n else if (type === \"threshold\") {\n const thresholds = domain;\n\n const thresholdFormat =\n tickFormat === undefined ? (d) => d : typeof tickFormat === \"string\" ? format(tickFormat) : tickFormat;\n\n // Construct a linear scale with evenly-spaced ticks for each of the\n // thresholds; the domain extends one beyond the threshold extent.\n x = applyRange(scaleLinear().domain([-1, range.length - 1]), [marginLeft, width - marginRight]);\n\n svg\n .append(\"g\")\n .attr(\"fill-opacity\", opacity)\n .selectAll()\n .data(range)\n .enter()\n .append(\"rect\")\n .attr(\"x\", (d, i) => x(i - 1))\n .attr(\"y\", marginTop)\n .attr(\"width\", (d, i) => x(i) - x(i - 1))\n .attr(\"height\", height - marginTop - marginBottom)\n .attr(\"fill\", (d) => d);\n\n ticks = map(thresholds, (_, i) => i);\n tickFormat = (i) => thresholdFormat(thresholds[i], i);\n }\n\n // Ordinal (hopefully!)\n else {\n x = applyRange(scaleBand().domain(domain), [marginLeft, width - marginRight]);\n\n svg\n .append(\"g\")\n .attr(\"fill-opacity\", opacity)\n .selectAll()\n .data(domain)\n .enter()\n .append(\"rect\")\n .attr(\"x\", x)\n .attr(\"y\", marginTop)\n .attr(\"width\", Math.max(0, x.bandwidth() - 1))\n .attr(\"height\", height - marginTop - marginBottom)\n .attr(\"fill\", scale);\n\n tickAdjust = () => {};\n }\n\n svg\n .append(\"g\")\n .attr(\"transform\", `translate(0,${height - marginBottom})`)\n .call(\n axisBottom(x)\n .ticks(Array.isArray(ticks) ? null : ticks, typeof tickFormat === \"string\" ? tickFormat : undefined)\n .tickFormat(typeof tickFormat === \"function\" ? tickFormat : undefined)\n .tickSize(tickSize)\n .tickValues(Array.isArray(ticks) ? ticks : null)\n )\n .attr(\"font-size\", null)\n .attr(\"font-family\", null)\n .attr(\"font-variant\", impliedString(fontVariant, \"normal\"))\n .call(tickAdjust)\n .call((g) => g.select(\".domain\").remove());\n\n if (label !== undefined) {\n svg\n .append(\"text\")\n .attr(\"x\", marginLeft)\n .attr(\"y\", marginTop - 6)\n .attr(\"fill\", \"currentColor\") // TODO move to stylesheet?\n .attr(\"font-weight\", \"bold\")\n .text(label);\n }\n\n return svg.node();\n}\n","import { select } from 'd3-selection';\nimport { legend } from '@observablehq/plot';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { IPlugin, PluginOptions } from '../index';\n\ninterface LegendOptions extends PluginOptions {\n enabled: boolean;\n itemSelector: string | null;\n label: string | null;\n width: number;\n}\n\nconst DEFAULT_SELECTOR = '#ch-plugin-legend';\n\nconst defaultOptions: LegendOptions = {\n // Whether to display the legend\n enabled: true,\n\n itemSelector: null,\n\n label: null,\n\n width: 130,\n};\n\nexport default class Legend implements IPlugin {\n name = 'Legend';\n\n calendar: CalHeatmap;\n\n root: any;\n\n shown: boolean;\n\n options: LegendOptions;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.root = null;\n this.shown = false;\n this.options = defaultOptions;\n }\n\n setup(pluginOptions?: Partial): void {\n this.options = { ...defaultOptions, ...pluginOptions };\n }\n\n paint(): Promise {\n const scaleOptions = this.calendar.options.options.scale;\n const { enabled, itemSelector } = this.options;\n\n if (!enabled || (itemSelector && select(itemSelector).empty())) {\n return this.destroy();\n }\n\n this.shown = true;\n\n this.root = select(\n itemSelector || this.calendar.options.options.itemSelector,\n );\n\n if (this.root.select(DEFAULT_SELECTOR).empty()) {\n this.root = this.root.append('div').attr('id', DEFAULT_SELECTOR.slice(1));\n } else {\n this.root = this.root.select(DEFAULT_SELECTOR);\n }\n\n // @ts-ignore\n const node = legend({\n ...scaleOptions,\n ...this.options,\n });\n\n this.root.selectAll('*').remove();\n this.root.append(() => node);\n\n return Promise.resolve();\n }\n\n destroy(): Promise {\n if (this.root !== null) {\n this.root.remove();\n this.root = null;\n }\n\n return Promise.resolve();\n }\n}\n"],"names":["fails","exec","error","descriptors","require$$0","Object","defineProperty","get","functionBindNative","test","bind","hasOwnProperty","NATIVE_BIND","FunctionPrototype","Function","prototype","call","uncurryThisWithBind","functionUncurryThis","fn","apply","arguments","isNullOrUndefined","it","$TypeError","TypeError","requireObjectCoercible","$Object","toObject","argument","require$$1","hasOwnProperty_1","hasOwn","key","DESCRIPTORS","getDescriptor","getOwnPropertyDescriptor","EXISTS","functionName","PROPER","name","CONFIGURABLE","configurable","makeBuiltIn$3","exports","documentAll","document","all","documentAll_1","IS_HTMLDDA","undefined","isCallable","check","Math","global","globalThis","window","self","this","defineGlobalProperty","value","writable","SHARED","sharedStore","store","require$$2","functionToString","toString","inspectSource","match","version","WeakMap","weakMapBasicDetection","String","isObject","objectDefineProperty","createElement","documentCreateElement","ie8DomDefine","a","v8PrototypeDefineBug","$String","anObject","functionCall","getBuiltIn","namespace","method","length","objectIsPrototypeOf","isPrototypeOf","engineUserAgent","navigator","userAgent","process","Deno","versions","v8","split","engineV8Version","V8_VERSION","symbolConstructorDetection","getOwnPropertySymbols","symbol","Symbol","sham","useSymbolAsUid","iterator","isSymbol","require$$3","$Symbol","tryToString","aCallable","getMethod","V","P","func","shared$3","sharedModule","push","mode","copyright","license","source","uncurryThis","id","postfix","random","uid","shared","NATIVE_SYMBOL","require$$4","USE_SYMBOL_AS_UID","require$$5","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","wellKnownSymbol","ordinaryToPrimitive","input","pref","val","valueOf","TO_PRIMITIVE","toPrimitive","result","exoticToPrim","toPropertyKey","IE8_DOM_DEFINE","V8_PROTOTYPE_DEFINE_BUG","$defineProperty","$getOwnPropertyDescriptor","ENUMERABLE","WRITABLE","f","O","Attributes","current","enumerable","set","has","createPropertyDescriptor","bitmap","definePropertyModule","createNonEnumerableProperty","object","keys","hiddenKeys","NATIVE_WEAK_MAP","sharedKey","require$$7","OBJECT_ALREADY_INITIALIZED","state","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","CONFIGURABLE_FUNCTION_NAME","require$$6","enforceInternalState","getInternalState","stringSlice","slice","replace","join","CONFIGURABLE_LENGTH","TEMPLATE","makeBuiltIn","makeBuiltInModule","options","getter","setter","arity","constructor","defineBuiltInAccessor","target","descriptor","FUNCTION_NAME_EXISTS","nameRE","regExpExec","objectGetOwnPropertyDescriptor","objectPropertyIsEnumerable","$propertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","classofRaw","classof","indexedObject","IndexedObject","toIndexedObject","propertyIsEnumerableModule","defineBuiltIn","simple","unsafe","nonConfigurable","nonWritable","ceil","floor","trunc","x","n","toIntegerOrInfinity","number","max","min","toLength","lengthOfArrayLike","obj","toAbsoluteIndex","index","integer","createMethod","IS_INCLUDES","$this","el","fromIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","i","enumBugKeys","internalObjectKeys","concat","objectGetOwnPropertyNames","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","ownKeys","getOwnPropertyDescriptorModule","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","toLowerCase","isForced_1","copyConstructorProperties","exceptions","_export","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","objectKeys","require$$8","$assign","assign","objectAssign","b","A","B","alphabet","forEach","chr","T","argumentsLength","S","j","toStringTagSupport","TO_STRING_TAG_SUPPORT","TO_STRING_TAG","CORRECT_ARGUMENTS","tag","tryGet","callee","engineIsNode","uncurryThisAccessor","aPossiblePrototype","objectSetPrototypeOf","setPrototypeOf","CORRECT_SETTER","Array","proto","__proto__","SPECIES","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","$location","defer","channel","port","isConstructor","called","aConstructor","functionApply","Reflect","functionBindContext","that","html","arraySlice","engineIsIos","validateArgumentsLength","passed","required","IS_IOS","require$$10","IS_NODE","require$$11","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","location","run","runner","eventListener","event","globalPostMessageDefer","postMessage","protocol","host","handler","args","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","task","Queue","head","tail","add","item","entry","next","notify","toggle","node","promise","then","engineIsIosPebble","Pebble","engineIsWebosWebkit","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","Promise","queueMicrotaskDescriptor","microtask","flush","parent","domain","exit","enter","resolve","createTextNode","observe","characterData","microtask_1","perform","promiseNativeConstructor","engineIsDeno","engineIsBrowser","NativePromiseConstructor","IS_BROWSER","IS_DENO","require$$9","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","promiseConstructorDetection","CONSTRUCTOR","REJECTION_EVENT","newPromiseCapability$2","PromiseCapability","C","reject","$$resolve","$$reject","newPromiseCapability","Internal","OwnPromiseCapability","nativeThen","$","setToStringTag","TAG","setSpecies","CONSTRUCTOR_NAME","Constructor","anInstance","Prototype","speciesConstructor","defaultConstructor","require$$14","require$$15","hostReportErrors","console","require$$17","require$$18","InternalStateModule","require$$19","require$$20","newPromiseCapabilityModule","require$$22","PROMISE","require$$21","NATIVE_PROMISE_SUBCLASSING","getInternalPromiseState","setInternalState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","isThenable","callReaction","reaction","exited","ok","fail","rejection","onHandleUnhandled","isReject","notified","reactions","onUnhandled","reason","initEvent","isUnhandled","emit","unwrap","internalReject","done","internalResolve","wrapper","executor","onFulfilled","onRejected","PromiseWrapper","wrap","iterators","Iterators","ITERATOR","ArrayPrototype","getIteratorMethod","isArrayIteratorMethod","getIterator","usingIterator","iteratorMethod","iteratorClose","kind","innerResult","innerError","Result","stopped","ResultPrototype","iterate","iterable","unboundFunction","iterFn","step","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","SAFE_CLOSING","iteratorWithReturn","return","from","checkCorrectnessOfIteration","SKIP_CLOSING","ITERATION_SUPPORT","promiseStaticsIncorrectIteration","capability","$promiseResolve","values","remaining","alreadyCalled","real","catch","race","r","promiseResolve","promiseCapability","defined","Number","isNaN","ascendingDefined","ascending","finite","isFinite","NaN","positive","negative","format","date","fallback","Date","hours","getUTCHours","minutes","getUTCMinutes","seconds","getUTCSeconds","milliseconds","getUTCMilliseconds","year","getUTCFullYear","pad","getUTCMonth","getUTCDate","width","padStart","re","parse","timeIntervals","Map","timeSecond","timeMinute","timeHour","timeDay","timeWeek","timeMonth","every","timeYear","timeMonday","timeTuesday","timeWednesday","timeThursday","timeFriday","timeSaturday","timeSunday","utcIntervals","utcSecond","utcMinute","utcHour","utcDay","utcWeek","utcMonth","utcYear","utcMonday","utcTuesday","utcWednesday","utcThursday","utcFriday","utcSaturday","utcSunday","maybeTimeInterval","interval","Error","maybeUtcInterval","TypedArray","getPrototypeOf","Uint8Array","objectToString","constant","coerceNumbers","map","coerceNumber","Float64Array","coerceDates","coerceDate","isoParse","maybeColorChannel","defaultValue","trim","startsWith","endsWith","color","isColor","maybeNumberChannel","arrayify","option","isScaleOptions","maybeInterval","isInteger","abs","d","offset","range","lo","hi","rangei","maybeRangeInterval","isOrdinal","isTemporal","isTemporalString","isNumericString","isNoneish","isNone","orderof","first","last","descending","position","radius","opacity","registry","sqrt4_3","sqrt","symbolHexagon","draw","context","size","rx","PI","ry","hy","moveTo","lineTo","closePath","symbols","symbolAsterisk","symbolCircle","symbolCross","symbolDiamond","symbolDiamond2","symbolPlus","symbolSquare","symbolSquare2","symbolStar","symbolTimes","symbolTriangle","symbolTriangle2","symbolWye","maybeSymbol","isSymbolObject","warn","message","pi","tau","createProjection","projection","inset","globalInset","insetTop","insetRight","insetBottom","insetLeft","dimensions","stream","clip","scaleProjection","geoAlbersUsa","conicProjection","geoAlbers","geoAzimuthalEqualArea","geoAzimuthalEquidistant","geoConicConformal","geoConicEqualArea","geoConicEquidistant","geoEqualEarth","geoEquirectangular","geoGnomonic","identity","reflectY","geoMercator","geoOrthographic","geoStereographic","geoTransverseMercator","namedProjection","height","marginLeft","marginRight","marginTop","marginBottom","dx","dy","x1","y1","x2","y2","s","geoClipRectangle","maybePostClip","transform","tx","ty","x0","y0","geoPath","bounds","k","geoTransform","point","y","kx","ky","rotate","precision","clipAngle","scale","translate","aspectRatio","parallels","fitSize","createContext","className","create","select","creator","documentElement","ordinalSchemes","schemeAccent","schemeCategory10","schemeDark2","schemePaired","schemePastel1","schemePastel2","schemeSet1","schemeSet2","schemeSet3","schemeTableau10","scheme11","schemeBrBG","interpolateBrBG","schemePRGn","interpolatePRGn","schemePiYG","interpolatePiYG","schemePuOr","interpolatePuOr","schemeRdBu","interpolateRdBu","schemeRdGy","interpolateRdGy","schemeRdYlBu","interpolateRdYlBu","schemeRdYlGn","interpolateRdYlGn","schemeSpectral","interpolateSpectral","scheme11r","scheme9","schemeBlues","interpolateBlues","schemeGreens","interpolateGreens","schemeGreys","interpolateGreys","schemeOranges","interpolateOranges","schemePurples","interpolatePurples","schemeReds","interpolateReds","schemei","interpolateTurbo","interpolateViridis","interpolateMagma","interpolateInferno","interpolatePlasma","interpolateCividis","interpolateCubehelixDefault","interpolateWarm","interpolateCool","schemeBuGn","interpolateBuGn","schemeBuPu","interpolateBuPu","schemeGnBu","interpolateGnBu","schemeOrRd","interpolateOrRd","schemePuBu","interpolatePuBu","schemePuBuGn","interpolatePuBuGn","schemePuRd","interpolatePuRd","schemeRdPu","interpolateRdPu","schemeYlGn","interpolateYlGn","schemeYlGnBu","interpolateYlGnBu","schemeYlOrBr","interpolateYlOrBr","schemeYlOrRd","interpolateYlOrRd","schemeicyclical","interpolateRainbow","interpolateSinebow","scheme","interpolate","quantize","t","reverse","ordinalScheme","ordinalRange","quantitativeSchemes","quantitativeScheme","divergingSchemes","Set","isDivergingScheme","flip","unit","interpolators","interpolateNumber","interpolateRgb","interpolateHsl","interpolateHcl","interpolateLab","maybeInterpolator","createScaleQ","channels","nice","clamp","zero","inferAutoDomain","unknown","round","inferRadialRange","inferLengthRange","interpolateRound","_","interpolatePiecewise","extent","sign","reverseof","maybeNiceInterval","maybeNice","createScalePow","exponent","scalePow","createScaleThreshold","isOrdered","scaleThreshold","inferDomain","inferZeroDomain","hint","find","h25","quantile","h50","median","inferLogDomain","v","inferQuantileDomain","createScaleD","pivot","symmetric","piecewise","mid","mindelta","maxdelta","invert","interpolator","createScaleDivergingPow","scaleDivergingPow","transformSqrt","pow","transformPow","createScaleDivergingSymlog","scaleDivergingSymlog","log1p","expm1","transformSymlog","transformIdentity","transformLog","log","exp","createScaleT","ordinalImplicit","createScaleO","createScaleOrdinal","fill","inferHint","stroke","inferSymbolHint","symbolsStroke","symbolsFill","inferSymbolRange","maybeBooleanRange","t0","scaleImplicit","scaleOrdinal","maybeRound","InternSet","sort","candidate","normalizeScale","typeProjection","some","asOrdinalType","filter","inferScaleType","isOrdinalScale","formatScaleType","coerceType","coerceSymbols","scaleDiverging","createScaleDiverging","createScaleDivergingSqrt","base","scaleDivergingLog","createScaleDivergingLog","scaleLinear","createScaleLinear","createScaleSqrt","quantiles","scaleQuantile","createScaleQuantile","thresholds","ticks","splice","pop","createScaleQuantize","scaleLog","createScaleLog","scaleSymlog","createScaleSymlog","scaleUtc","createScaleUtc","scaleTime","createScaleTime","align","padding","scalePoint","createScalePoint","paddingInner","paddingOuter","scaleBand","createScaleBand","scaleIdentity","createScale","description","coerceValues","c","numberFormat","compute","cacheValue","cacheKeys","memoize1","locale","Intl","NumberFormat","formatIsoDate","isoFormat","impliedString","impliedValue","formatNumber","formatAuto","validClassName","maybeClassName","applyInlineStyles","selection","style","property","element","inferFontVariant","maybeScale","legendItems","swatch","columns","tickFormat","fontVariant","swatchSize","swatchWidth","swatchHeight","utcFormat","maybeAutoTickFormat","swatches","attr","extraStyle","selectAll","append","text","ownerDocument","div","insert","legendRegistry","fillOpacity","strokeOpacity","strokeWidth","vf","cf","vs","cs","sf","ss","p","path","legendColor","legend","rgb","interpolateOpacity","legendOptions","label","rest","o","defaults","inherit","isThresholdScale","legendSwatches","tickSize","svg","tickAdjust","g","applyRange","rangeRound","copy","Infinity","canvas","context2","getContext","fillStyle","fillRect","toDataURL","thresholdFormat","bandwidth","axisBottom","isArray","tickValues","remove","legendRamp","DEFAULT_SELECTOR","defaultOptions","enabled","itemSelector","Legend","calendar","_classCallCheck","root","shown","pluginOptions","scaleOptions","_this$options","destroy"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140]} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.esm.js b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.esm.js new file mode 100644 index 0000000..686a383 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.esm.js @@ -0,0 +1,6128 @@ +import { select, create as create$3 } from 'd3-selection'; +import { ascending, timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear, timeMonday, timeTuesday, timeWednesday, timeThursday, timeFriday, timeSaturday, timeSunday, utcSecond, utcMinute, utcHour, utcDay, utcWeek, utcMonth, utcYear, utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSunday, descending, range, symbolAsterisk, symbolCircle, symbolCross, symbolDiamond, symbolDiamond2, symbolPlus, symbolSquare, symbolSquare2, symbolStar, symbolTimes, symbolTriangle, symbolTriangle2, symbolWye, schemeAccent, schemeCategory10, schemeDark2, schemePaired, schemePastel1, schemePastel2, schemeSet1, schemeSet2, schemeSet3, schemeTableau10, quantize, interpolateBrBG, interpolatePRGn, interpolatePiYG, interpolatePuOr, interpolateRdBu, interpolateRdGy, interpolateRdYlBu, interpolateRdYlGn, interpolateSpectral, interpolateBlues, interpolateGreens, interpolateGreys, interpolatePurples, interpolateReds, interpolateOranges, interpolateTurbo, interpolateViridis, interpolateMagma, interpolateInferno, interpolatePlasma, interpolateCividis, interpolateCubehelixDefault, interpolateWarm, interpolateCool, interpolateBuGn, interpolateBuPu, interpolateGnBu, interpolateOrRd, interpolatePuBuGn, interpolatePuBu, interpolatePuRd, interpolateRdPu, interpolateYlGnBu, interpolateYlGn, interpolateYlOrBr, interpolateYlOrRd, interpolateRainbow, interpolateSinebow, schemeBrBG, schemePRGn, schemePiYG, schemePuOr, schemeRdBu, schemeRdGy, schemeRdYlBu, schemeRdYlGn, schemeSpectral, schemeBlues, schemeGreens, schemeGreys, schemeOranges, schemePurples, schemeReds, schemeBuGn, schemeBuPu, schemeGnBu, schemeOrRd, schemePuBu, schemePuBuGn, schemePuRd, schemeRdPu, schemeYlGn, schemeYlGnBu, schemeYlOrBr, schemeYlOrRd, scaleLinear, scalePow, scaleLog, scaleSymlog, scaleQuantile, extent, ticks, interpolateNumber, reverse, scaleThreshold, scaleIdentity, max as max$3, interpolateRgb, interpolateRound, min as min$3, quantile, median, interpolateHsl, interpolateHcl, interpolateLab, scaleDiverging, scaleDivergingPow, scaleDivergingLog, scaleDivergingSymlog, piecewise, scaleTime, scaleUtc, scaleImplicit, scaleOrdinal, scalePoint, scaleBand, InternSet, sort, symbolsStroke, symbolsFill } from 'd3'; + +function _iterableToArrayLimit(arr, i) { + var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; + if (null != _i) { + var _s, + _e, + _x, + _r, + _arr = [], + _n = !0, + _d = !1; + try { + if (_x = (_i = _i.call(arr)).next, 0 === i) { + if (Object(_i) !== _i) return; + _n = !1; + } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); + } catch (err) { + _d = !0, _e = err; + } finally { + try { + if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; + } finally { + if (_d) throw _e; + } + } + return _arr; + } +} +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } +} +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; +} +function _defineProperty(obj, key, value) { + key = _toPropertyKey(key); + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; +} +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); +} +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + return arr2; +} +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); +} +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); +} + +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +var fails$p = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + +var fails$o = fails$p; + +// Detect IE8's incomplete defineProperty implementation +var descriptors = !fails$o(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; +}); + +var fails$n = fails$p; + +var functionBindNative = !fails$n(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); +}); + +var NATIVE_BIND$3 = functionBindNative; + +var FunctionPrototype$3 = Function.prototype; +var call$g = FunctionPrototype$3.call; +var uncurryThisWithBind = NATIVE_BIND$3 && FunctionPrototype$3.bind.bind(call$g, call$g); + +var functionUncurryThis = NATIVE_BIND$3 ? uncurryThisWithBind : function (fn) { + return function () { + return call$g.apply(fn, arguments); + }; +}; + +// we can't use just `it == null` since of `document.all` special case +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec +var isNullOrUndefined$7 = function (it) { + return it === null || it === undefined; +}; + +var isNullOrUndefined$6 = isNullOrUndefined$7; + +var $TypeError$f = TypeError; + +// `RequireObjectCoercible` abstract operation +// https://tc39.es/ecma262/#sec-requireobjectcoercible +var requireObjectCoercible$5 = function (it) { + if (isNullOrUndefined$6(it)) throw new $TypeError$f("Can't call method on " + it); + return it; +}; + +var requireObjectCoercible$4 = requireObjectCoercible$5; + +var $Object$4 = Object; + +// `ToObject` abstract operation +// https://tc39.es/ecma262/#sec-toobject +var toObject$8 = function (argument) { + return $Object$4(requireObjectCoercible$4(argument)); +}; + +var uncurryThis$p = functionUncurryThis; +var toObject$7 = toObject$8; + +var hasOwnProperty = uncurryThis$p({}.hasOwnProperty); + +// `HasOwnProperty` abstract operation +// https://tc39.es/ecma262/#sec-hasownproperty +// eslint-disable-next-line es/no-object-hasown -- safe +var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject$7(it), key); +}; + +var DESCRIPTORS$d = descriptors; +var hasOwn$b = hasOwnProperty_1; + +var FunctionPrototype$2 = Function.prototype; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getDescriptor = DESCRIPTORS$d && Object.getOwnPropertyDescriptor; + +var EXISTS$1 = hasOwn$b(FunctionPrototype$2, 'name'); +// additional protection from minified / mangled / dropped function names +var PROPER = EXISTS$1 && (function something() { /* empty */ }).name === 'something'; +var CONFIGURABLE$1 = EXISTS$1 && (!DESCRIPTORS$d || (DESCRIPTORS$d && getDescriptor(FunctionPrototype$2, 'name').configurable)); + +var functionName = { + EXISTS: EXISTS$1, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE$1 +}; + +var makeBuiltIn$3 = {exports: {}}; + +var documentAll$2 = typeof document == 'object' && document.all; + +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot +// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing +var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined; + +var documentAll_1 = { + all: documentAll$2, + IS_HTMLDDA: IS_HTMLDDA +}; + +var $documentAll$1 = documentAll_1; + +var documentAll$1 = $documentAll$1.all; + +// `IsCallable` abstract operation +// https://tc39.es/ecma262/#sec-iscallable +var isCallable$m = $documentAll$1.IS_HTMLDDA ? function (argument) { + return typeof argument == 'function' || argument === documentAll$1; +} : function (argument) { + return typeof argument == 'function'; +}; + +var check = function (it) { + return it && it.Math === Math && it; +}; + +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +var global$k = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + +var global$j = global$k; + +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty$7 = Object.defineProperty; + +var defineGlobalProperty$3 = function (key, value) { + try { + defineProperty$7(global$j, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$j[key] = value; + } return value; +}; + +var global$i = global$k; +var defineGlobalProperty$2 = defineGlobalProperty$3; + +var SHARED = '__core-js_shared__'; +var store$3 = global$i[SHARED] || defineGlobalProperty$2(SHARED, {}); + +var sharedStore = store$3; + +var uncurryThis$o = functionUncurryThis; +var isCallable$l = isCallable$m; +var store$2 = sharedStore; + +var functionToString$1 = uncurryThis$o(Function.toString); + +// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper +if (!isCallable$l(store$2.inspectSource)) { + store$2.inspectSource = function (it) { + return functionToString$1(it); + }; +} + +var inspectSource$3 = store$2.inspectSource; + +var global$h = global$k; +var isCallable$k = isCallable$m; + +var WeakMap$1 = global$h.WeakMap; + +var weakMapBasicDetection = isCallable$k(WeakMap$1) && /native code/.test(String(WeakMap$1)); + +var isCallable$j = isCallable$m; +var $documentAll = documentAll_1; + +var documentAll = $documentAll.all; + +var isObject$i = $documentAll.IS_HTMLDDA ? function (it) { + return typeof it == 'object' ? it !== null : isCallable$j(it) || it === documentAll; +} : function (it) { + return typeof it == 'object' ? it !== null : isCallable$j(it); +}; + +var objectDefineProperty = {}; + +var global$g = global$k; +var isObject$h = isObject$i; + +var document$3 = global$g.document; +// typeof document.createElement is 'object' in old IE +var EXISTS = isObject$h(document$3) && isObject$h(document$3.createElement); + +var documentCreateElement$2 = function (it) { + return EXISTS ? document$3.createElement(it) : {}; +}; + +var DESCRIPTORS$c = descriptors; +var fails$m = fails$p; +var createElement$1 = documentCreateElement$2; + +// Thanks to IE8 for its funny defineProperty +var ie8DomDefine = !DESCRIPTORS$c && !fails$m(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { + get: function () { return 7; } + }).a !== 7; +}); + +var DESCRIPTORS$b = descriptors; +var fails$l = fails$p; + +// V8 ~ Chrome 36- +// https://bugs.chromium.org/p/v8/issues/detail?id=3334 +var v8PrototypeDefineBug = DESCRIPTORS$b && fails$l(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; +}); + +var isObject$g = isObject$i; + +var $String$5 = String; +var $TypeError$e = TypeError; + +// `Assert: Type(argument) is Object` +var anObject$c = function (argument) { + if (isObject$g(argument)) return argument; + throw new $TypeError$e($String$5(argument) + ' is not an object'); +}; + +var NATIVE_BIND$2 = functionBindNative; + +var call$f = Function.prototype.call; + +var functionCall = NATIVE_BIND$2 ? call$f.bind(call$f) : function () { + return call$f.apply(call$f, arguments); +}; + +var global$f = global$k; +var isCallable$i = isCallable$m; + +var aFunction = function (argument) { + return isCallable$i(argument) ? argument : undefined; +}; + +var getBuiltIn$7 = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$f[namespace]) : global$f[namespace] && global$f[namespace][method]; +}; + +var uncurryThis$n = functionUncurryThis; + +var objectIsPrototypeOf = uncurryThis$n({}.isPrototypeOf); + +var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || ''; + +var global$e = global$k; +var userAgent$5 = engineUserAgent; + +var process$3 = global$e.process; +var Deno$1 = global$e.Deno; +var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version; +var v8 = versions && versions.v8; +var match, version; + +if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); +} + +// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` +// so check `userAgent` even if `.v8` exists, but 0 +if (!version && userAgent$5) { + match = userAgent$5.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$5.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } +} + +var engineV8Version = version; + +/* eslint-disable es/no-symbol -- required for testing */ +var V8_VERSION$3 = engineV8Version; +var fails$k = fails$p; +var global$d = global$k; + +var $String$4 = global$d.String; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing +var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$k(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String$4(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$3 && V8_VERSION$3 < 41; +}); + +/* eslint-disable es/no-symbol -- required for testing */ +var NATIVE_SYMBOL$1 = symbolConstructorDetection; + +var useSymbolAsUid = NATIVE_SYMBOL$1 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + +var getBuiltIn$6 = getBuiltIn$7; +var isCallable$h = isCallable$m; +var isPrototypeOf$2 = objectIsPrototypeOf; +var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + +var $Object$3 = Object; + +var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + var $Symbol = getBuiltIn$6('Symbol'); + return isCallable$h($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it)); +}; + +var $String$3 = String; + +var tryToString$5 = function (argument) { + try { + return $String$3(argument); + } catch (error) { + return 'Object'; + } +}; + +var isCallable$g = isCallable$m; +var tryToString$4 = tryToString$5; + +var $TypeError$d = TypeError; + +// `Assert: IsCallable(argument) is true` +var aCallable$a = function (argument) { + if (isCallable$g(argument)) return argument; + throw new $TypeError$d(tryToString$4(argument) + ' is not a function'); +}; + +var aCallable$9 = aCallable$a; +var isNullOrUndefined$5 = isNullOrUndefined$7; + +// `GetMethod` abstract operation +// https://tc39.es/ecma262/#sec-getmethod +var getMethod$3 = function (V, P) { + var func = V[P]; + return isNullOrUndefined$5(func) ? undefined : aCallable$9(func); +}; + +var call$e = functionCall; +var isCallable$f = isCallable$m; +var isObject$f = isObject$i; + +var $TypeError$c = TypeError; + +// `OrdinaryToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-ordinarytoprimitive +var ordinaryToPrimitive$1 = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable$f(fn = input.toString) && !isObject$f(val = call$e(fn, input))) return val; + if (isCallable$f(fn = input.valueOf) && !isObject$f(val = call$e(fn, input))) return val; + if (pref !== 'string' && isCallable$f(fn = input.toString) && !isObject$f(val = call$e(fn, input))) return val; + throw new $TypeError$c("Can't convert object to primitive value"); +}; + +var shared$3 = {exports: {}}; + +var store$1 = sharedStore; + +(shared$3.exports = function (key, value) { + return store$1[key] || (store$1[key] = value !== undefined ? value : {}); +})('versions', []).push({ + version: '3.34.0', + mode: 'global', + copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE', + source: 'https://github.com/zloirock/core-js' +}); + +var sharedExports = shared$3.exports; + +var uncurryThis$m = functionUncurryThis; + +var id$2 = 0; +var postfix = Math.random(); +var toString$8 = uncurryThis$m(1.0.toString); + +var uid$3 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$8(++id$2 + postfix, 36); +}; + +var global$c = global$k; +var shared$2 = sharedExports; +var hasOwn$a = hasOwnProperty_1; +var uid$2 = uid$3; +var NATIVE_SYMBOL = symbolConstructorDetection; +var USE_SYMBOL_AS_UID = useSymbolAsUid; + +var Symbol$1 = global$c.Symbol; +var WellKnownSymbolsStore = shared$2('wks'); +var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$2; + +var wellKnownSymbol$k = function (name) { + if (!hasOwn$a(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$a(Symbol$1, name) + ? Symbol$1[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; +}; + +var call$d = functionCall; +var isObject$e = isObject$i; +var isSymbol$1 = isSymbol$2; +var getMethod$2 = getMethod$3; +var ordinaryToPrimitive = ordinaryToPrimitive$1; +var wellKnownSymbol$j = wellKnownSymbol$k; + +var $TypeError$b = TypeError; +var TO_PRIMITIVE = wellKnownSymbol$j('toPrimitive'); + +// `ToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-toprimitive +var toPrimitive$1 = function (input, pref) { + if (!isObject$e(input) || isSymbol$1(input)) return input; + var exoticToPrim = getMethod$2(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$d(exoticToPrim, input, pref); + if (!isObject$e(result) || isSymbol$1(result)) return result; + throw new $TypeError$b("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); +}; + +var toPrimitive = toPrimitive$1; +var isSymbol = isSymbol$2; + +// `ToPropertyKey` abstract operation +// https://tc39.es/ecma262/#sec-topropertykey +var toPropertyKey$3 = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; +}; + +var DESCRIPTORS$a = descriptors; +var IE8_DOM_DEFINE$1 = ie8DomDefine; +var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug; +var anObject$b = anObject$c; +var toPropertyKey$2 = toPropertyKey$3; + +var $TypeError$a = TypeError; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var $defineProperty = Object.defineProperty; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; +var ENUMERABLE = 'enumerable'; +var CONFIGURABLE = 'configurable'; +var WRITABLE = 'writable'; + +// `Object.defineProperty` method +// https://tc39.es/ecma262/#sec-object.defineproperty +objectDefineProperty.f = DESCRIPTORS$a ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) { + anObject$b(O); + P = toPropertyKey$2(P); + anObject$b(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor$1(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); +} : $defineProperty : function defineProperty(O, P, Attributes) { + anObject$b(O); + P = toPropertyKey$2(P); + anObject$b(Attributes); + if (IE8_DOM_DEFINE$1) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$a('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + +var createPropertyDescriptor$4 = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + +var DESCRIPTORS$9 = descriptors; +var definePropertyModule$4 = objectDefineProperty; +var createPropertyDescriptor$3 = createPropertyDescriptor$4; + +var createNonEnumerableProperty$5 = DESCRIPTORS$9 ? function (object, key, value) { + return definePropertyModule$4.f(object, key, createPropertyDescriptor$3(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + +var shared$1 = sharedExports; +var uid$1 = uid$3; + +var keys = shared$1('keys'); + +var sharedKey$3 = function (key) { + return keys[key] || (keys[key] = uid$1(key)); +}; + +var hiddenKeys$5 = {}; + +var NATIVE_WEAK_MAP = weakMapBasicDetection; +var global$b = global$k; +var isObject$d = isObject$i; +var createNonEnumerableProperty$4 = createNonEnumerableProperty$5; +var hasOwn$9 = hasOwnProperty_1; +var shared = sharedStore; +var sharedKey$2 = sharedKey$3; +var hiddenKeys$4 = hiddenKeys$5; + +var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; +var TypeError$2 = global$b.TypeError; +var WeakMap = global$b.WeakMap; +var set$1, get, has; + +var enforce = function (it) { + return has(it) ? get(it) : set$1(it, {}); +}; + +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject$d(it) || (state = get(it)).type !== TYPE) { + throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; +}; + +if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set$1 = function (it, metadata) { + if (store.has(it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get = function (it) { + return store.get(it) || {}; + }; + has = function (it) { + return store.has(it); + }; +} else { + var STATE = sharedKey$2('state'); + hiddenKeys$4[STATE] = true; + set$1 = function (it, metadata) { + if (hasOwn$9(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty$4(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn$9(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn$9(it, STATE); + }; +} + +var internalState = { + set: set$1, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor +}; + +var uncurryThis$l = functionUncurryThis; +var fails$j = fails$p; +var isCallable$e = isCallable$m; +var hasOwn$8 = hasOwnProperty_1; +var DESCRIPTORS$8 = descriptors; +var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE; +var inspectSource$2 = inspectSource$3; +var InternalStateModule$5 = internalState; + +var enforceInternalState = InternalStateModule$5.enforce; +var getInternalState$2 = InternalStateModule$5.get; +var $String$2 = String; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty$6 = Object.defineProperty; +var stringSlice$3 = uncurryThis$l(''.slice); +var replace$1 = uncurryThis$l(''.replace); +var join = uncurryThis$l([].join); + +var CONFIGURABLE_LENGTH = DESCRIPTORS$8 && !fails$j(function () { + return defineProperty$6(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; +}); + +var TEMPLATE = String(String).split('String'); + +var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) { + if (stringSlice$3($String$2(name), 0, 7) === 'Symbol(') { + name = '[' + replace$1($String$2(name), /^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn$8(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) { + if (DESCRIPTORS$8) defineProperty$6(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn$8(options, 'arity') && value.length !== options.arity) { + defineProperty$6(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn$8(options, 'constructor') && options.constructor) { + if (DESCRIPTORS$8) defineProperty$6(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn$8(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; +}; + +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +// eslint-disable-next-line no-extend-native -- required +Function.prototype.toString = makeBuiltIn$2(function toString() { + return isCallable$e(this) && getInternalState$2(this).source || inspectSource$2(this); +}, 'toString'); + +var makeBuiltInExports = makeBuiltIn$3.exports; + +var makeBuiltIn$1 = makeBuiltInExports; +var defineProperty$5 = objectDefineProperty; + +var defineBuiltInAccessor$3 = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn$1(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn$1(descriptor.set, name, { setter: true }); + return defineProperty$5.f(target, name, descriptor); +}; + +var DESCRIPTORS$7 = descriptors; +var FUNCTION_NAME_EXISTS = functionName.EXISTS; +var uncurryThis$k = functionUncurryThis; +var defineBuiltInAccessor$2 = defineBuiltInAccessor$3; + +var FunctionPrototype$1 = Function.prototype; +var functionToString = uncurryThis$k(FunctionPrototype$1.toString); +var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; +var regExpExec = uncurryThis$k(nameRE.exec); +var NAME = 'name'; + +// Function instances `.name` property +// https://tc39.es/ecma262/#sec-function-instances-name +if (DESCRIPTORS$7 && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor$2(FunctionPrototype$1, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); +} + +var objectGetOwnPropertyDescriptor = {}; + +var objectPropertyIsEnumerable = {}; + +var $propertyIsEnumerable$1 = {}.propertyIsEnumerable; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor$3 = Object.getOwnPropertyDescriptor; + +// Nashorn ~ JDK8 bug +var NASHORN_BUG = getOwnPropertyDescriptor$3 && !$propertyIsEnumerable$1.call({ 1: 2 }, 1); + +// `Object.prototype.propertyIsEnumerable` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable +objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor$3(this, V); + return !!descriptor && descriptor.enumerable; +} : $propertyIsEnumerable$1; + +var uncurryThis$j = functionUncurryThis; + +var toString$7 = uncurryThis$j({}.toString); +var stringSlice$2 = uncurryThis$j(''.slice); + +var classofRaw$2 = function (it) { + return stringSlice$2(toString$7(it), 8, -1); +}; + +var uncurryThis$i = functionUncurryThis; +var fails$i = fails$p; +var classof$a = classofRaw$2; + +var $Object$2 = Object; +var split = uncurryThis$i(''.split); + +// fallback for non-array-like ES3 and non-enumerable old V8 strings +var indexedObject = fails$i(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object$2('z').propertyIsEnumerable(0); +}) ? function (it) { + return classof$a(it) === 'String' ? split(it, '') : $Object$2(it); +} : $Object$2; + +// toObject with fallback for non-array-like ES3 strings +var IndexedObject$3 = indexedObject; +var requireObjectCoercible$3 = requireObjectCoercible$5; + +var toIndexedObject$9 = function (it) { + return IndexedObject$3(requireObjectCoercible$3(it)); +}; + +var DESCRIPTORS$6 = descriptors; +var call$c = functionCall; +var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; +var createPropertyDescriptor$2 = createPropertyDescriptor$4; +var toIndexedObject$8 = toIndexedObject$9; +var toPropertyKey$1 = toPropertyKey$3; +var hasOwn$7 = hasOwnProperty_1; +var IE8_DOM_DEFINE = ie8DomDefine; + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor +objectGetOwnPropertyDescriptor.f = DESCRIPTORS$6 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$8(O); + P = toPropertyKey$1(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn$7(O, P)) return createPropertyDescriptor$2(!call$c(propertyIsEnumerableModule$1.f, O, P), O[P]); +}; + +var isCallable$d = isCallable$m; +var definePropertyModule$3 = objectDefineProperty; +var makeBuiltIn = makeBuiltInExports; +var defineGlobalProperty$1 = defineGlobalProperty$3; + +var defineBuiltIn$8 = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable$d(value)) makeBuiltIn(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty$1(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule$3.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; +}; + +var objectGetOwnPropertyNames = {}; + +var ceil = Math.ceil; +var floor$1 = Math.floor; + +// `Math.trunc` method +// https://tc39.es/ecma262/#sec-math.trunc +// eslint-disable-next-line es/no-math-trunc -- safe +var mathTrunc = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor$1 : ceil)(n); +}; + +var trunc = mathTrunc; + +// `ToIntegerOrInfinity` abstract operation +// https://tc39.es/ecma262/#sec-tointegerorinfinity +var toIntegerOrInfinity$3 = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); +}; + +var toIntegerOrInfinity$2 = toIntegerOrInfinity$3; + +var max$2 = Math.max; +var min$2 = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). +var toAbsoluteIndex$3 = function (index, length) { + var integer = toIntegerOrInfinity$2(index); + return integer < 0 ? max$2(integer + length, 0) : min$2(integer, length); +}; + +var toIntegerOrInfinity$1 = toIntegerOrInfinity$3; + +var min$1 = Math.min; + +// `ToLength` abstract operation +// https://tc39.es/ecma262/#sec-tolength +var toLength$2 = function (argument) { + return argument > 0 ? min$1(toIntegerOrInfinity$1(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + +var toLength$1 = toLength$2; + +// `LengthOfArrayLike` abstract operation +// https://tc39.es/ecma262/#sec-lengthofarraylike +var lengthOfArrayLike$8 = function (obj) { + return toLength$1(obj.length); +}; + +var toIndexedObject$7 = toIndexedObject$9; +var toAbsoluteIndex$2 = toAbsoluteIndex$3; +var lengthOfArrayLike$7 = lengthOfArrayLike$8; + +// `Array.prototype.{ indexOf, includes }` methods implementation +var createMethod$4 = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject$7($this); + var length = lengthOfArrayLike$7(O); + var index = toAbsoluteIndex$2(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod$4(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod$4(false) +}; + +var uncurryThis$h = functionUncurryThis; +var hasOwn$6 = hasOwnProperty_1; +var toIndexedObject$6 = toIndexedObject$9; +var indexOf = arrayIncludes.indexOf; +var hiddenKeys$3 = hiddenKeys$5; + +var push$3 = uncurryThis$h([].push); + +var objectKeysInternal = function (object, names) { + var O = toIndexedObject$6(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn$6(hiddenKeys$3, key) && hasOwn$6(O, key) && push$3(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn$6(O, key = names[i++])) { + ~indexOf(result, key) || push$3(result, key); + } + return result; +}; + +// IE8- don't enum bug keys +var enumBugKeys$3 = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + +var internalObjectKeys$1 = objectKeysInternal; +var enumBugKeys$2 = enumBugKeys$3; + +var hiddenKeys$2 = enumBugKeys$2.concat('length', 'prototype'); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +// eslint-disable-next-line es/no-object-getownpropertynames -- safe +objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys$2); +}; + +var objectGetOwnPropertySymbols = {}; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe +objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; + +var getBuiltIn$5 = getBuiltIn$7; +var uncurryThis$g = functionUncurryThis; +var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames; +var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; +var anObject$a = anObject$c; + +var concat$1 = uncurryThis$g([].concat); + +// all object keys, includes non-enumerable and symbols +var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule$1.f(anObject$a(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f; + return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys; +}; + +var hasOwn$5 = hasOwnProperty_1; +var ownKeys = ownKeys$1; +var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; +var definePropertyModule$2 = objectDefineProperty; + +var copyConstructorProperties$1 = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule$2.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn$5(target, key) && !(exceptions && hasOwn$5(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } +}; + +var fails$h = fails$p; +var isCallable$c = isCallable$m; + +var replacement = /#|\.prototype\./; + +var isForced$3 = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable$c(detection) ? fails$h(detection) + : !!detection; +}; + +var normalize = isForced$3.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced$3.data = {}; +var NATIVE = isForced$3.NATIVE = 'N'; +var POLYFILL = isForced$3.POLYFILL = 'P'; + +var isForced_1 = isForced$3; + +var global$a = global$k; +var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f; +var createNonEnumerableProperty$3 = createNonEnumerableProperty$5; +var defineBuiltIn$7 = defineBuiltIn$8; +var defineGlobalProperty = defineGlobalProperty$3; +var copyConstructorProperties = copyConstructorProperties$1; +var isForced$2 = isForced_1; + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key +*/ +var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global$a; + } else if (STATIC) { + target = global$a[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = (global$a[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor$2(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced$2(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty$3(sourceProperty, 'sham', true); + } + defineBuiltIn$7(target, key, sourceProperty, options); + } +}; + +var internalObjectKeys = objectKeysInternal; +var enumBugKeys$1 = enumBugKeys$3; + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +// eslint-disable-next-line es/no-object-keys -- safe +var objectKeys$3 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys$1); +}; + +var DESCRIPTORS$5 = descriptors; +var uncurryThis$f = functionUncurryThis; +var call$b = functionCall; +var fails$g = fails$p; +var objectKeys$2 = objectKeys$3; +var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; +var propertyIsEnumerableModule = objectPropertyIsEnumerable; +var toObject$6 = toObject$8; +var IndexedObject$2 = indexedObject; + +// eslint-disable-next-line es/no-object-assign -- safe +var $assign = Object.assign; +// eslint-disable-next-line es/no-object-defineproperty -- required for testing +var defineProperty$4 = Object.defineProperty; +var concat = uncurryThis$f([].concat); + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +var objectAssign = !$assign || fails$g(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$5 && $assign({ b: 1 }, $assign(defineProperty$4({}, 'a', { + enumerable: true, + get: function () { + defineProperty$4(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys$2($assign({}, B)).join('') !== alphabet; +}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject$6(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject$2(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys$2(S), getOwnPropertySymbols(S)) : objectKeys$2(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$5 || call$b(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; +} : $assign; + +var $$m = _export; +var assign = objectAssign; + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +// eslint-disable-next-line es/no-object-assign -- required for testing +$$m({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign +}); + +var wellKnownSymbol$i = wellKnownSymbol$k; + +var TO_STRING_TAG$2 = wellKnownSymbol$i('toStringTag'); +var test$1 = {}; + +test$1[TO_STRING_TAG$2] = 'z'; + +var toStringTagSupport = String(test$1) === '[object z]'; + +var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; +var isCallable$b = isCallable$m; +var classofRaw$1 = classofRaw$2; +var wellKnownSymbol$h = wellKnownSymbol$k; + +var TO_STRING_TAG$1 = wellKnownSymbol$h('toStringTag'); +var $Object$1 = Object; + +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +var classof$9 = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object$1(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw$1(O) + // ES3 arguments fallback + : (result = classofRaw$1(O)) === 'Object' && isCallable$b(O.callee) ? 'Arguments' : result; +}; + +var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; +var classof$8 = classof$9; + +// `Object.prototype.toString` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.tostring +var objectToString$1 = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$8(this) + ']'; +}; + +var TO_STRING_TAG_SUPPORT = toStringTagSupport; +var defineBuiltIn$6 = defineBuiltIn$8; +var toString$6 = objectToString$1; + +// `Object.prototype.toString` method +// https://tc39.es/ecma262/#sec-object.prototype.tostring +if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn$6(Object.prototype, 'toString', toString$6, { unsafe: true }); +} + +var global$9 = global$k; +var classof$7 = classofRaw$2; + +var engineIsNode = classof$7(global$9.process) === 'process'; + +var uncurryThis$e = functionUncurryThis; +var aCallable$8 = aCallable$a; + +var functionUncurryThisAccessor = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis$e(aCallable$8(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } +}; + +var isCallable$a = isCallable$m; + +var $String$1 = String; +var $TypeError$9 = TypeError; + +var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$a(argument)) return argument; + throw new $TypeError$9("Can't set " + $String$1(argument) + ' as a prototype'); +}; + +/* eslint-disable no-proto -- safe */ +var uncurryThisAccessor = functionUncurryThisAccessor; +var anObject$9 = anObject$c; +var aPossiblePrototype = aPossiblePrototype$1; + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +// Works with __proto__ only. Old v8 can't work with null proto objects. +// eslint-disable-next-line es/no-object-setprototypeof -- safe +var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject$9(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + +var defineProperty$3 = objectDefineProperty.f; +var hasOwn$4 = hasOwnProperty_1; +var wellKnownSymbol$g = wellKnownSymbol$k; + +var TO_STRING_TAG = wellKnownSymbol$g('toStringTag'); + +var setToStringTag$5 = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$4(target, TO_STRING_TAG)) { + defineProperty$3(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + +var getBuiltIn$4 = getBuiltIn$7; +var defineBuiltInAccessor$1 = defineBuiltInAccessor$3; +var wellKnownSymbol$f = wellKnownSymbol$k; +var DESCRIPTORS$4 = descriptors; + +var SPECIES$5 = wellKnownSymbol$f('species'); + +var setSpecies$2 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME); + + if (DESCRIPTORS$4 && Constructor && !Constructor[SPECIES$5]) { + defineBuiltInAccessor$1(Constructor, SPECIES$5, { + configurable: true, + get: function () { return this; } + }); + } +}; + +var isPrototypeOf$1 = objectIsPrototypeOf; + +var $TypeError$8 = TypeError; + +var anInstance$4 = function (it, Prototype) { + if (isPrototypeOf$1(Prototype, it)) return it; + throw new $TypeError$8('Incorrect invocation'); +}; + +var uncurryThis$d = functionUncurryThis; +var fails$f = fails$p; +var isCallable$9 = isCallable$m; +var classof$6 = classof$9; +var getBuiltIn$3 = getBuiltIn$7; +var inspectSource$1 = inspectSource$3; + +var noop = function () { /* empty */ }; +var empty = []; +var construct = getBuiltIn$3('Reflect', 'construct'); +var constructorRegExp = /^\s*(?:class|function)\b/; +var exec = uncurryThis$d(constructorRegExp.exec); +var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + +var isConstructorModern = function isConstructor(argument) { + if (!isCallable$9(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } +}; + +var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$9(argument)) return false; + switch (classof$6(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } +}; + +isConstructorLegacy.sham = true; + +// `IsConstructor` abstract operation +// https://tc39.es/ecma262/#sec-isconstructor +var isConstructor$4 = !construct || fails$f(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; +}) ? isConstructorLegacy : isConstructorModern; + +var isConstructor$3 = isConstructor$4; +var tryToString$3 = tryToString$5; + +var $TypeError$7 = TypeError; + +// `Assert: IsConstructor(argument) is true` +var aConstructor$1 = function (argument) { + if (isConstructor$3(argument)) return argument; + throw new $TypeError$7(tryToString$3(argument) + ' is not a constructor'); +}; + +var anObject$8 = anObject$c; +var aConstructor = aConstructor$1; +var isNullOrUndefined$4 = isNullOrUndefined$7; +var wellKnownSymbol$e = wellKnownSymbol$k; + +var SPECIES$4 = wellKnownSymbol$e('species'); + +// `SpeciesConstructor` abstract operation +// https://tc39.es/ecma262/#sec-speciesconstructor +var speciesConstructor$1 = function (O, defaultConstructor) { + var C = anObject$8(O).constructor; + var S; + return C === undefined || isNullOrUndefined$4(S = anObject$8(C)[SPECIES$4]) ? defaultConstructor : aConstructor(S); +}; + +var NATIVE_BIND$1 = functionBindNative; + +var FunctionPrototype = Function.prototype; +var apply$1 = FunctionPrototype.apply; +var call$a = FunctionPrototype.call; + +// eslint-disable-next-line es/no-reflect -- safe +var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$a.bind(apply$1) : function () { + return call$a.apply(apply$1, arguments); +}); + +var classofRaw = classofRaw$2; +var uncurryThis$c = functionUncurryThis; + +var functionUncurryThisClause = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis$c(fn); +}; + +var uncurryThis$b = functionUncurryThisClause; +var aCallable$7 = aCallable$a; +var NATIVE_BIND = functionBindNative; + +var bind$7 = uncurryThis$b(uncurryThis$b.bind); + +// optional / simple context binding +var functionBindContext = function (fn, that) { + aCallable$7(fn); + return that === undefined ? fn : NATIVE_BIND ? bind$7(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; +}; + +var getBuiltIn$2 = getBuiltIn$7; + +var html$2 = getBuiltIn$2('document', 'documentElement'); + +var uncurryThis$a = functionUncurryThis; + +var arraySlice$3 = uncurryThis$a([].slice); + +var $TypeError$6 = TypeError; + +var validateArgumentsLength$1 = function (passed, required) { + if (passed < required) throw new $TypeError$6('Not enough arguments'); + return passed; +}; + +var userAgent$4 = engineUserAgent; + +// eslint-disable-next-line redos/no-vulnerable -- safe +var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$4); + +var global$8 = global$k; +var apply = functionApply; +var bind$6 = functionBindContext; +var isCallable$8 = isCallable$m; +var hasOwn$3 = hasOwnProperty_1; +var fails$e = fails$p; +var html$1 = html$2; +var arraySlice$2 = arraySlice$3; +var createElement = documentCreateElement$2; +var validateArgumentsLength = validateArgumentsLength$1; +var IS_IOS$1 = engineIsIos; +var IS_NODE$3 = engineIsNode; + +var set = global$8.setImmediate; +var clear = global$8.clearImmediate; +var process$2 = global$8.process; +var Dispatch = global$8.Dispatch; +var Function$1 = global$8.Function; +var MessageChannel = global$8.MessageChannel; +var String$1 = global$8.String; +var counter = 0; +var queue$2 = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var $location, defer, channel, port; + +fails$e(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = global$8.location; +}); + +var run = function (id) { + if (hasOwn$3(queue$2, id)) { + var fn = queue$2[id]; + delete queue$2[id]; + fn(); + } +}; + +var runner = function (id) { + return function () { + run(id); + }; +}; + +var eventListener = function (event) { + run(event.data); +}; + +var globalPostMessageDefer = function (id) { + // old engines have not location.origin + global$8.postMessage(String$1(id), $location.protocol + '//' + $location.host); +}; + +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!set || !clear) { + set = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable$8(handler) ? handler : Function$1(handler); + var args = arraySlice$2(arguments, 1); + queue$2[++counter] = function () { + apply(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue$2[id]; + }; + // Node.js 0.8- + if (IS_NODE$3) { + defer = function (id) { + process$2.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS$1) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind$6(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global$8.addEventListener && + isCallable$8(global$8.postMessage) && + !global$8.importScripts && + $location && $location.protocol !== 'file:' && + !fails$e(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + global$8.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html$1.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } +} + +var task$1 = { + set: set, + clear: clear +}; + +var Queue$2 = function () { + this.head = null; + this.tail = null; +}; + +Queue$2.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } +}; + +var queue$1 = Queue$2; + +var userAgent$3 = engineUserAgent; + +var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$3) && typeof Pebble != 'undefined'; + +var userAgent$2 = engineUserAgent; + +var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent$2); + +var global$7 = global$k; +var bind$5 = functionBindContext; +var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; +var macrotask = task$1.set; +var Queue$1 = queue$1; +var IS_IOS = engineIsIos; +var IS_IOS_PEBBLE = engineIsIosPebble; +var IS_WEBOS_WEBKIT = engineIsWebosWebkit; +var IS_NODE$2 = engineIsNode; + +var MutationObserver = global$7.MutationObserver || global$7.WebKitMutationObserver; +var document$2 = global$7.document; +var process$1 = global$7.process; +var Promise$1 = global$7.Promise; +// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` +var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$7, 'queueMicrotask'); +var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; +var notify$1, toggle, node, promise, then; + +// modern engines have queueMicrotask method +if (!microtask$1) { + var queue = new Queue$1(); + + var flush = function () { + var parent, fn; + if (IS_NODE$2 && (parent = process$1.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify$1(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { + toggle = true; + node = document$2.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify$1 = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise$1.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise$1; + then = bind$5(promise.then, promise); + notify$1 = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE$2) { + notify$1 = function () { + process$1.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind$5(macrotask, global$7); + notify$1 = function () { + macrotask(flush); + }; + } + + microtask$1 = function (fn) { + if (!queue.head) notify$1(); + queue.add(fn); + }; +} + +var microtask_1 = microtask$1; + +var hostReportErrors$1 = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } +}; + +var perform$4 = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } +}; + +var global$6 = global$k; + +var promiseNativeConstructor = global$6.Promise; + +/* global Deno -- Deno case */ +var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object'; + +var IS_DENO$1 = engineIsDeno; +var IS_NODE$1 = engineIsNode; + +var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 + && typeof window == 'object' + && typeof document == 'object'; + +var global$5 = global$k; +var NativePromiseConstructor$3 = promiseNativeConstructor; +var isCallable$7 = isCallable$m; +var isForced$1 = isForced_1; +var inspectSource = inspectSource$3; +var wellKnownSymbol$d = wellKnownSymbol$k; +var IS_BROWSER = engineIsBrowser; +var IS_DENO = engineIsDeno; +var V8_VERSION$2 = engineV8Version; + +NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype; +var SPECIES$3 = wellKnownSymbol$d('species'); +var SUBCLASSING = false; +var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$7(global$5.PromiseRejectionEvent); + +var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION$2 === 66) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION$2 || V8_VERSION$2 < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES$3] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1; +}); + +var promiseConstructorDetection = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1, + SUBCLASSING: SUBCLASSING +}; + +var newPromiseCapability$2 = {}; + +var aCallable$6 = aCallable$a; + +var $TypeError$5 = TypeError; + +var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError$5('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable$6(resolve); + this.reject = aCallable$6(reject); +}; + +// `NewPromiseCapability` abstract operation +// https://tc39.es/ecma262/#sec-newpromisecapability +newPromiseCapability$2.f = function (C) { + return new PromiseCapability(C); +}; + +var $$l = _export; +var IS_NODE = engineIsNode; +var global$4 = global$k; +var call$9 = functionCall; +var defineBuiltIn$5 = defineBuiltIn$8; +var setPrototypeOf$2 = objectSetPrototypeOf; +var setToStringTag$4 = setToStringTag$5; +var setSpecies$1 = setSpecies$2; +var aCallable$5 = aCallable$a; +var isCallable$6 = isCallable$m; +var isObject$c = isObject$i; +var anInstance$3 = anInstance$4; +var speciesConstructor = speciesConstructor$1; +var task = task$1.set; +var microtask = microtask_1; +var hostReportErrors = hostReportErrors$1; +var perform$3 = perform$4; +var Queue = queue$1; +var InternalStateModule$4 = internalState; +var NativePromiseConstructor$2 = promiseNativeConstructor; +var PromiseConstructorDetection = promiseConstructorDetection; +var newPromiseCapabilityModule$4 = newPromiseCapability$2; + +var PROMISE = 'Promise'; +var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR; +var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; +var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; +var getInternalPromiseState = InternalStateModule$4.getterFor(PROMISE); +var setInternalState$4 = InternalStateModule$4.set; +var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype; +var PromiseConstructor = NativePromiseConstructor$2; +var PromisePrototype = NativePromisePrototype$1; +var TypeError$1 = global$4.TypeError; +var document$1 = global$4.document; +var process = global$4.process; +var newPromiseCapability$1 = newPromiseCapabilityModule$4.f; +var newGenericPromiseCapability = newPromiseCapability$1; + +var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$4.dispatchEvent); +var UNHANDLED_REJECTION = 'unhandledrejection'; +var REJECTION_HANDLED = 'rejectionhandled'; +var PENDING = 0; +var FULFILLED = 1; +var REJECTED = 2; +var HANDLED = 1; +var UNHANDLED = 2; + +var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + +// helpers +var isThenable = function (it) { + var then; + return isObject$c(it) && isCallable$6(then = it.then) ? then : false; +}; + +var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$9(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } +}; + +var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); +}; + +var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$1.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global$4.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$4['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); +}; + +var onUnhandled = function (state) { + call$9(task, global$4, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform$3(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); +}; + +var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; +}; + +var onHandleUnhandled = function (state) { + call$9(task, global$4, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); +}; + +var bind$4 = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; +}; + +var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); +}; + +var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call$9(then, value, + bind$4(internalResolve, wrapper, state), + bind$4(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } +}; + +// constructor polyfill +if (FORCED_PROMISE_CONSTRUCTOR$4) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance$3(this, PromisePrototype); + aCallable$5(executor); + call$9(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind$4(internalResolve, state), bind$4(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState$4(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: undefined + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn$5(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable$6(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$6(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind$4(internalResolve, state); + this.reject = bind$4(internalReject, state); + }; + + newPromiseCapabilityModule$4.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (isCallable$6(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) { + nativeThen = NativePromisePrototype$1.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn$5(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call$9(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype$1.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf$2) { + setPrototypeOf$2(NativePromisePrototype$1, PromisePrototype); + } + } +} + +$$l({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, { + Promise: PromiseConstructor +}); + +setToStringTag$4(PromiseConstructor, PROMISE, false); +setSpecies$1(PROMISE); + +var iterators = {}; + +var wellKnownSymbol$c = wellKnownSymbol$k; +var Iterators$4 = iterators; + +var ITERATOR$5 = wellKnownSymbol$c('iterator'); +var ArrayPrototype$1 = Array.prototype; + +// check on default Array iterator +var isArrayIteratorMethod$2 = function (it) { + return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$5] === it); +}; + +var classof$5 = classof$9; +var getMethod$1 = getMethod$3; +var isNullOrUndefined$3 = isNullOrUndefined$7; +var Iterators$3 = iterators; +var wellKnownSymbol$b = wellKnownSymbol$k; + +var ITERATOR$4 = wellKnownSymbol$b('iterator'); + +var getIteratorMethod$3 = function (it) { + if (!isNullOrUndefined$3(it)) return getMethod$1(it, ITERATOR$4) + || getMethod$1(it, '@@iterator') + || Iterators$3[classof$5(it)]; +}; + +var call$8 = functionCall; +var aCallable$4 = aCallable$a; +var anObject$7 = anObject$c; +var tryToString$2 = tryToString$5; +var getIteratorMethod$2 = getIteratorMethod$3; + +var $TypeError$4 = TypeError; + +var getIterator$2 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$2(argument) : usingIterator; + if (aCallable$4(iteratorMethod)) return anObject$7(call$8(iteratorMethod, argument)); + throw new $TypeError$4(tryToString$2(argument) + ' is not iterable'); +}; + +var call$7 = functionCall; +var anObject$6 = anObject$c; +var getMethod = getMethod$3; + +var iteratorClose$2 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$6(iterator); + try { + innerResult = getMethod(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$7(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$6(innerResult); + return value; +}; + +var bind$3 = functionBindContext; +var call$6 = functionCall; +var anObject$5 = anObject$c; +var tryToString$1 = tryToString$5; +var isArrayIteratorMethod$1 = isArrayIteratorMethod$2; +var lengthOfArrayLike$6 = lengthOfArrayLike$8; +var isPrototypeOf = objectIsPrototypeOf; +var getIterator$1 = getIterator$2; +var getIteratorMethod$1 = getIteratorMethod$3; +var iteratorClose$1 = iteratorClose$2; + +var $TypeError$3 = TypeError; + +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; + +var ResultPrototype = Result.prototype; + +var iterate$6 = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind$3(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose$1(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject$5(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod$1(iterable); + if (!iterFn) throw new $TypeError$3(tryToString$1(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod$1(iterFn)) { + for (index = 0, length = lengthOfArrayLike$6(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator$1(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call$6(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose$1(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); +}; + +var wellKnownSymbol$a = wellKnownSymbol$k; + +var ITERATOR$3 = wellKnownSymbol$a('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR$3] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +var checkCorrectnessOfIteration$3 = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR$3] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + +var NativePromiseConstructor$1 = promiseNativeConstructor; +var checkCorrectnessOfIteration$2 = checkCorrectnessOfIteration$3; +var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR; + +var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration$2(function (iterable) { + NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ }); +}); + +var $$k = _export; +var call$5 = functionCall; +var aCallable$3 = aCallable$a; +var newPromiseCapabilityModule$3 = newPromiseCapability$2; +var perform$2 = perform$4; +var iterate$5 = iterate$6; +var PROMISE_STATICS_INCORRECT_ITERATION$2 = promiseStaticsIncorrectIteration; + +// `Promise.all` method +// https://tc39.es/ecma262/#sec-promise.all +$$k({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$2 }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$3.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform$2(function () { + var $promiseResolve = aCallable$3(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$5(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$5($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var $$j = _export; +var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR; +var NativePromiseConstructor = promiseNativeConstructor; +var getBuiltIn$1 = getBuiltIn$7; +var isCallable$5 = isCallable$m; +var defineBuiltIn$4 = defineBuiltIn$8; + +var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + +// `Promise.prototype.catch` method +// https://tc39.es/ecma262/#sec-promise.prototype.catch +$$j({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } +}); + +// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` +if (isCallable$5(NativePromiseConstructor)) { + var method = getBuiltIn$1('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn$4(NativePromisePrototype, 'catch', method, { unsafe: true }); + } +} + +var $$i = _export; +var call$4 = functionCall; +var aCallable$2 = aCallable$a; +var newPromiseCapabilityModule$2 = newPromiseCapability$2; +var perform$1 = perform$4; +var iterate$4 = iterate$6; +var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration; + +// `Promise.race` method +// https://tc39.es/ecma262/#sec-promise.race +$$i({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$2.f(C); + var reject = capability.reject; + var result = perform$1(function () { + var $promiseResolve = aCallable$2(C.resolve); + iterate$4(iterable, function (promise) { + call$4($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var $$h = _export; +var call$3 = functionCall; +var newPromiseCapabilityModule$1 = newPromiseCapability$2; +var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR; + +// `Promise.reject` method +// https://tc39.es/ecma262/#sec-promise.reject +$$h({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule$1.f(this); + call$3(capability.reject, undefined, r); + return capability.promise; + } +}); + +var anObject$4 = anObject$c; +var isObject$b = isObject$i; +var newPromiseCapability = newPromiseCapability$2; + +var promiseResolve$1 = function (C, x) { + anObject$4(C); + if (isObject$b(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + +var $$g = _export; +var getBuiltIn = getBuiltIn$7; +var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR; +var promiseResolve = promiseResolve$1; + +getBuiltIn('Promise'); + +// `Promise.resolve` method +// https://tc39.es/ecma262/#sec-promise.resolve +$$g({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(this, x); + } +}); + +var objectDefineProperties = {}; + +var DESCRIPTORS$3 = descriptors; +var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; +var definePropertyModule$1 = objectDefineProperty; +var anObject$3 = anObject$c; +var toIndexedObject$5 = toIndexedObject$9; +var objectKeys$1 = objectKeys$3; + +// `Object.defineProperties` method +// https://tc39.es/ecma262/#sec-object.defineproperties +// eslint-disable-next-line es/no-object-defineproperties -- safe +objectDefineProperties.f = DESCRIPTORS$3 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject$3(O); + var props = toIndexedObject$5(Properties); + var keys = objectKeys$1(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]); + return O; +}; + +/* global ActiveXObject -- old IE, WSH */ +var anObject$2 = anObject$c; +var definePropertiesModule = objectDefineProperties; +var enumBugKeys = enumBugKeys$3; +var hiddenKeys$1 = hiddenKeys$5; +var html = html$2; +var documentCreateElement$1 = documentCreateElement$2; +var sharedKey$1 = sharedKey$3; + +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO$1 = sharedKey$1('IE_PROTO'); + +var EmptyConstructor = function () { /* empty */ }; + +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; + +// Create object with fake `null` prototype: use ActiveX Object with cleared prototype +var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; +}; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement$1('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; + +// Check for document.domain and active x support +// No need to use active x approach when document.domain is not set +// see https://github.com/es-shims/es5-shim/issues/150 +// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 +// avoid IE GC bug +var activeXDocument; +var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; + +hiddenKeys$1[IE_PROTO$1] = true; + +// `Object.create` method +// https://tc39.es/ecma262/#sec-object.create +// eslint-disable-next-line es/no-object-create -- safe +var objectCreate = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject$2(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO$1] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : definePropertiesModule.f(result, Properties); +}; + +var wellKnownSymbol$9 = wellKnownSymbol$k; +var create$2 = objectCreate; +var defineProperty$2 = objectDefineProperty.f; + +var UNSCOPABLES = wellKnownSymbol$9('unscopables'); +var ArrayPrototype = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype[UNSCOPABLES] === undefined) { + defineProperty$2(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create$2(null) + }); +} + +// add a key to Array.prototype[@@unscopables] +var addToUnscopables$2 = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; +}; + +var fails$d = fails$p; + +var correctPrototypeGetter = !fails$d(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + +var hasOwn$2 = hasOwnProperty_1; +var isCallable$4 = isCallable$m; +var toObject$5 = toObject$8; +var sharedKey = sharedKey$3; +var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter; + +var IE_PROTO = sharedKey('IE_PROTO'); +var $Object = Object; +var ObjectPrototype = $Object.prototype; + +// `Object.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.getprototypeof +// eslint-disable-next-line es/no-object-getprototypeof -- safe +var objectGetPrototypeOf$1 = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) { + var object = toObject$5(O); + if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable$4(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof $Object ? ObjectPrototype : null; +}; + +var fails$c = fails$p; +var isCallable$3 = isCallable$m; +var isObject$a = isObject$i; +var getPrototypeOf$1 = objectGetPrototypeOf$1; +var defineBuiltIn$3 = defineBuiltIn$8; +var wellKnownSymbol$8 = wellKnownSymbol$k; + +var ITERATOR$2 = wellKnownSymbol$8('iterator'); +var BUGGY_SAFARI_ITERATORS$1 = false; + +// `%IteratorPrototype%` object +// https://tc39.es/ecma262/#sec-%iteratorprototype%-object +var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator; + +/* eslint-disable es/no-array-prototype-keys -- safe */ +if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype; + } +} + +var NEW_ITERATOR_PROTOTYPE = !isObject$a(IteratorPrototype$2) || fails$c(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype$2[ITERATOR$2].call(test) !== test; +}); + +if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {}; + +// `%IteratorPrototype%[@@iterator]()` method +// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator +if (!isCallable$3(IteratorPrototype$2[ITERATOR$2])) { + defineBuiltIn$3(IteratorPrototype$2, ITERATOR$2, function () { + return this; + }); +} + +var iteratorsCore = { + IteratorPrototype: IteratorPrototype$2, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1 +}; + +var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; +var create$1 = objectCreate; +var createPropertyDescriptor$1 = createPropertyDescriptor$4; +var setToStringTag$3 = setToStringTag$5; +var Iterators$2 = iterators; + +var returnThis$1 = function () { return this; }; + +var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create$1(IteratorPrototype$1, { next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next) }); + setToStringTag$3(IteratorConstructor, TO_STRING_TAG, false); + Iterators$2[TO_STRING_TAG] = returnThis$1; + return IteratorConstructor; +}; + +var $$f = _export; +var call$2 = functionCall; +var FunctionName = functionName; +var isCallable$2 = isCallable$m; +var createIteratorConstructor = iteratorCreateConstructor; +var getPrototypeOf = objectGetPrototypeOf$1; +var setPrototypeOf$1 = objectSetPrototypeOf; +var setToStringTag$2 = setToStringTag$5; +var createNonEnumerableProperty$2 = createNonEnumerableProperty$5; +var defineBuiltIn$2 = defineBuiltIn$8; +var wellKnownSymbol$7 = wellKnownSymbol$k; +var Iterators$1 = iterators; +var IteratorsCore = iteratorsCore; + +var PROPER_FUNCTION_NAME$1 = FunctionName.PROPER; +var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; +var IteratorPrototype = IteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR$1 = wellKnownSymbol$7('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; + +var returnThis = function () { return this; }; + +var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND]; + + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } + + return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR$1] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf$1) { + setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$1])) { + defineBuiltIn$2(CurrentIteratorPrototype, ITERATOR$1, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag$2(CurrentIteratorPrototype, TO_STRING_TAG, true); + } + } + + // fix Array.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME$1 && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call$2(nativeIterator, this); }; + } + } + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + defineBuiltIn$2(IterablePrototype, KEY, methods[KEY]); + } + } else $$f({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if (IterablePrototype[ITERATOR$1] !== defaultIterator) { + defineBuiltIn$2(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT }); + } + Iterators$1[NAME] = defaultIterator; + + return methods; +}; + +// `CreateIterResultObject` abstract operation +// https://tc39.es/ecma262/#sec-createiterresultobject +var createIterResultObject$3 = function (value, done) { + return { value: value, done: done }; +}; + +var toIndexedObject$4 = toIndexedObject$9; +var addToUnscopables$1 = addToUnscopables$2; +var Iterators = iterators; +var InternalStateModule$3 = internalState; +var defineProperty$1 = objectDefineProperty.f; +var defineIterator$2 = iteratorDefine; +var createIterResultObject$2 = createIterResultObject$3; +var DESCRIPTORS$2 = descriptors; + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState$3 = InternalStateModule$3.set; +var getInternalState$1 = InternalStateModule$3.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.es/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.es/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.es/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.es/ecma262/#sec-createarrayiterator +var es_array_iterator = defineIterator$2(Array, 'Array', function (iterated, kind) { + setInternalState$3(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject$4(iterated), // target + index: 0, // next index + kind: kind // kind + }); +// `%ArrayIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState$1(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return createIterResultObject$2(undefined, true); + } + switch (state.kind) { + case 'keys': return createIterResultObject$2(index, false); + case 'values': return createIterResultObject$2(target[index], false); + } return createIterResultObject$2([index, target[index]], false); +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.es/ecma262/#sec-createunmappedargumentsobject +// https://tc39.es/ecma262/#sec-createmappedargumentsobject +var values = Iterators.Arguments = Iterators.Array; + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables$1('keys'); +addToUnscopables$1('values'); +addToUnscopables$1('entries'); + +// V8 ~ Chrome 45- bug +if (DESCRIPTORS$2 && values.name !== 'values') try { + defineProperty$1(values, 'name', { value: 'values' }); +} catch (error) { /* empty */ } + +var classof$4 = classof$9; + +var $String = String; + +var toString$5 = function (argument) { + if (classof$4(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string'); + return $String(argument); +}; + +var uncurryThis$9 = functionUncurryThis; +var toIntegerOrInfinity = toIntegerOrInfinity$3; +var toString$4 = toString$5; +var requireObjectCoercible$2 = requireObjectCoercible$5; + +var charAt$1 = uncurryThis$9(''.charAt); +var charCodeAt = uncurryThis$9(''.charCodeAt); +var stringSlice$1 = uncurryThis$9(''.slice); + +var createMethod$3 = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = toString$4(requireObjectCoercible$2($this)); + var position = toIntegerOrInfinity(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = charCodeAt(S, position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt$1(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice$1(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; +}; + +var stringMultibyte = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod$3(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod$3(true) +}; + +var charAt = stringMultibyte.charAt; +var toString$3 = toString$5; +var InternalStateModule$2 = internalState; +var defineIterator$1 = iteratorDefine; +var createIterResultObject$1 = createIterResultObject$3; + +var STRING_ITERATOR = 'String Iterator'; +var setInternalState$2 = InternalStateModule$2.set; +var getInternalState = InternalStateModule$2.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-string.prototype-@@iterator +defineIterator$1(String, 'String', function (iterated) { + setInternalState$2(this, { + type: STRING_ITERATOR, + string: toString$3(iterated), + index: 0 + }); +// `%StringIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next +}, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return createIterResultObject$1(undefined, true); + point = charAt(string, index); + state.index += point.length; + return createIterResultObject$1(point, false); +}); + +var internalMetadata = {exports: {}}; + +var objectGetOwnPropertyNamesExternal = {}; + +var toPropertyKey = toPropertyKey$3; +var definePropertyModule = objectDefineProperty; +var createPropertyDescriptor = createPropertyDescriptor$4; + +var createProperty$4 = function (object, key, value) { + var propertyKey = toPropertyKey(key); + if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; +}; + +var toAbsoluteIndex$1 = toAbsoluteIndex$3; +var lengthOfArrayLike$5 = lengthOfArrayLike$8; +var createProperty$3 = createProperty$4; + +var $Array$3 = Array; +var max$1 = Math.max; + +var arraySliceSimple = function (O, start, end) { + var length = lengthOfArrayLike$5(O); + var k = toAbsoluteIndex$1(start, length); + var fin = toAbsoluteIndex$1(end === undefined ? length : end, length); + var result = $Array$3(max$1(fin - k, 0)); + var n = 0; + for (; k < fin; k++, n++) createProperty$3(result, n, O[k]); + result.length = n; + return result; +}; + +/* eslint-disable es/no-object-getownpropertynames -- safe */ +var classof$3 = classofRaw$2; +var toIndexedObject$3 = toIndexedObject$9; +var $getOwnPropertyNames = objectGetOwnPropertyNames.f; +var arraySlice$1 = arraySliceSimple; + +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function (it) { + try { + return $getOwnPropertyNames(it); + } catch (error) { + return arraySlice$1(windowNames); + } +}; + +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames(it) { + return windowNames && classof$3(it) === 'Window' + ? getWindowNames(it) + : $getOwnPropertyNames(toIndexedObject$3(it)); +}; + +// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it +var fails$b = fails$p; + +var arrayBufferNonExtensible = fails$b(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } +}); + +var fails$a = fails$p; +var isObject$9 = isObject$i; +var classof$2 = classofRaw$2; +var ARRAY_BUFFER_NON_EXTENSIBLE = arrayBufferNonExtensible; + +// eslint-disable-next-line es/no-object-isextensible -- safe +var $isExtensible = Object.isExtensible; +var FAILS_ON_PRIMITIVES$1 = fails$a(function () { $isExtensible(1); }); + +// `Object.isExtensible` method +// https://tc39.es/ecma262/#sec-object.isextensible +var objectIsExtensible = (FAILS_ON_PRIMITIVES$1 || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) { + if (!isObject$9(it)) return false; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof$2(it) === 'ArrayBuffer') return false; + return $isExtensible ? $isExtensible(it) : true; +} : $isExtensible; + +var fails$9 = fails$p; + +var freezing = !fails$9(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); +}); + +var $$e = _export; +var uncurryThis$8 = functionUncurryThis; +var hiddenKeys = hiddenKeys$5; +var isObject$8 = isObject$i; +var hasOwn$1 = hasOwnProperty_1; +var defineProperty = objectDefineProperty.f; +var getOwnPropertyNamesModule = objectGetOwnPropertyNames; +var getOwnPropertyNamesExternalModule = objectGetOwnPropertyNamesExternal; +var isExtensible = objectIsExtensible; +var uid = uid$3; +var FREEZING = freezing; + +var REQUIRED = false; +var METADATA = uid('meta'); +var id$1 = 0; + +var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + id$1++, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey$1 = function (it, create) { + // return a primitive with prefix + if (!isObject$8(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData$1 = function (it, create) { + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn$1(it, METADATA)) setMetadata(it); + return it; +}; + +var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis$8([].splice); + var test = {}; + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $$e({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } +}; + +var meta = internalMetadata.exports = { + enable: enable, + fastKey: fastKey$1, + getWeakData: getWeakData$1, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; + +var internalMetadataExports = internalMetadata.exports; + +var isCallable$1 = isCallable$m; +var isObject$7 = isObject$i; +var setPrototypeOf = objectSetPrototypeOf; + +// makes subclassing work correct for wrapped built-ins +var inheritIfRequired$1 = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable$1(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject$7(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; +}; + +var $$d = _export; +var global$3 = global$k; +var uncurryThis$7 = functionUncurryThis; +var isForced = isForced_1; +var defineBuiltIn$1 = defineBuiltIn$8; +var InternalMetadataModule = internalMetadataExports; +var iterate$3 = iterate$6; +var anInstance$2 = anInstance$4; +var isCallable = isCallable$m; +var isNullOrUndefined$2 = isNullOrUndefined$7; +var isObject$6 = isObject$i; +var fails$8 = fails$p; +var checkCorrectnessOfIteration$1 = checkCorrectnessOfIteration$3; +var setToStringTag$1 = setToStringTag$5; +var inheritIfRequired = inheritIfRequired$1; + +var collection$2 = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global$3[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis$7(NativePrototype[KEY]); + defineBuiltIn$1(NativePrototype, KEY, + KEY === 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY === 'delete' ? function (key) { + return IS_WEAK && !isObject$6(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'get' ? function get(key) { + return IS_WEAK && !isObject$6(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'has' ? function has(key) { + return IS_WEAK && !isObject$6(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails$8(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails$8(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration$1(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails$8(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance$2(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (!isNullOrUndefined$2(iterable)) iterate$3(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $$d({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported); + + setToStringTag$1(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + +var defineBuiltIn = defineBuiltIn$8; + +var defineBuiltIns$2 = function (target, src, options) { + for (var key in src) defineBuiltIn(target, key, src[key], options); + return target; +}; + +var classof$1 = classofRaw$2; + +// `IsArray` abstract operation +// https://tc39.es/ecma262/#sec-isarray +// eslint-disable-next-line es/no-array-isarray -- safe +var isArray$3 = Array.isArray || function isArray(argument) { + return classof$1(argument) === 'Array'; +}; + +var isArray$2 = isArray$3; +var isConstructor$2 = isConstructor$4; +var isObject$5 = isObject$i; +var wellKnownSymbol$6 = wellKnownSymbol$k; + +var SPECIES$2 = wellKnownSymbol$6('species'); +var $Array$2 = Array; + +// a part of `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +var arraySpeciesConstructor$1 = function (originalArray) { + var C; + if (isArray$2(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor$2(C) && (C === $Array$2 || isArray$2(C.prototype))) C = undefined; + else if (isObject$5(C)) { + C = C[SPECIES$2]; + if (C === null) C = undefined; + } + } return C === undefined ? $Array$2 : C; +}; + +var arraySpeciesConstructor = arraySpeciesConstructor$1; + +// `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +var arraySpeciesCreate$2 = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); +}; + +var bind$2 = functionBindContext; +var uncurryThis$6 = functionUncurryThis; +var IndexedObject$1 = indexedObject; +var toObject$4 = toObject$8; +var lengthOfArrayLike$4 = lengthOfArrayLike$8; +var arraySpeciesCreate$1 = arraySpeciesCreate$2; + +var push$2 = uncurryThis$6([].push); + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation +var createMethod$2 = function (TYPE) { + var IS_MAP = TYPE === 1; + var IS_FILTER = TYPE === 2; + var IS_SOME = TYPE === 3; + var IS_EVERY = TYPE === 4; + var IS_FIND_INDEX = TYPE === 6; + var IS_FILTER_REJECT = TYPE === 7; + var NO_HOLES = TYPE === 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject$4($this); + var self = IndexedObject$1(O); + var length = lengthOfArrayLike$4(self); + var boundFunction = bind$2(callbackfn, that); + var index = 0; + var create = specificCreate || arraySpeciesCreate$1; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push$2(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push$2(target, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +var arrayIteration = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod$2(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod$2(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod$2(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod$2(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod$2(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod$2(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod$2(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod$2(7) +}; + +var uncurryThis$5 = functionUncurryThis; +var defineBuiltIns$1 = defineBuiltIns$2; +var getWeakData = internalMetadataExports.getWeakData; +var anInstance$1 = anInstance$4; +var anObject$1 = anObject$c; +var isNullOrUndefined$1 = isNullOrUndefined$7; +var isObject$4 = isObject$i; +var iterate$2 = iterate$6; +var ArrayIterationModule = arrayIteration; +var hasOwn = hasOwnProperty_1; +var InternalStateModule$1 = internalState; + +var setInternalState$1 = InternalStateModule$1.set; +var internalStateGetterFor$1 = InternalStateModule$1.getterFor; +var find = ArrayIterationModule.find; +var findIndex = ArrayIterationModule.findIndex; +var splice = uncurryThis$5([].splice); +var id = 0; + +// fallback for uncaught frozen keys +var uncaughtFrozenStore = function (state) { + return state.frozen || (state.frozen = new UncaughtFrozenStore()); +}; + +var UncaughtFrozenStore = function () { + this.entries = []; +}; + +var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); +}; + +UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) splice(this.entries, index, 1); + return !!~index; + } +}; + +var collectionWeak$1 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance$1(that, Prototype); + setInternalState$1(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (!isNullOrUndefined$1(iterable)) iterate$2(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor$1(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject$1(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + defineBuiltIns$1(Prototype, { + // `{ WeakMap, WeakSet }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.delete + // https://tc39.es/ecma262/#sec-weakset.prototype.delete + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject$4(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && hasOwn(data, state.id) && delete data[state.id]; + }, + // `{ WeakMap, WeakSet }.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.has + // https://tc39.es/ecma262/#sec-weakset.prototype.has + has: function has(key) { + var state = getInternalState(this); + if (!isObject$4(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && hasOwn(data, state.id); + } + }); + + defineBuiltIns$1(Prototype, IS_MAP ? { + // `WeakMap.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.get + get: function get(key) { + var state = getInternalState(this); + if (isObject$4(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // `WeakMap.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.set + set: function set(key, value) { + return define(this, key, value); + } + } : { + // `WeakSet.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-weakset.prototype.add + add: function add(value) { + return define(this, value, true); + } + }); + + return Constructor; + } +}; + +var collection$1 = collection$2; +var collectionWeak = collectionWeak$1; + +// `WeakSet` constructor +// https://tc39.es/ecma262/#sec-weakset-constructor +collection$1('WeakSet', function (init) { + return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionWeak); + +// iterable DOM collections +// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods +var domIterables = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + +// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList` +var documentCreateElement = documentCreateElement$2; + +var classList = documentCreateElement('span').classList; +var DOMTokenListPrototype$2 = classList && classList.constructor && classList.constructor.prototype; + +var domTokenListPrototype = DOMTokenListPrototype$2 === Object.prototype ? undefined : DOMTokenListPrototype$2; + +var global$2 = global$k; +var DOMIterables$1 = domIterables; +var DOMTokenListPrototype$1 = domTokenListPrototype; +var ArrayIteratorMethods = es_array_iterator; +var createNonEnumerableProperty$1 = createNonEnumerableProperty$5; +var setToStringTag = setToStringTag$5; +var wellKnownSymbol$5 = wellKnownSymbol$k; + +var ITERATOR = wellKnownSymbol$5('iterator'); +var ArrayValues = ArrayIteratorMethods.values; + +var handlePrototype$1 = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty$1(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + setToStringTag(CollectionPrototype, COLLECTION_NAME, true); + if (DOMIterables$1[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty$1(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } +}; + +for (var COLLECTION_NAME$1 in DOMIterables$1) { + handlePrototype$1(global$2[COLLECTION_NAME$1] && global$2[COLLECTION_NAME$1].prototype, COLLECTION_NAME$1); +} + +handlePrototype$1(DOMTokenListPrototype$1, 'DOMTokenList'); + +var fails$7 = fails$p; +var wellKnownSymbol$4 = wellKnownSymbol$k; +var V8_VERSION$1 = engineV8Version; + +var SPECIES$1 = wellKnownSymbol$4('species'); + +var arrayMethodHasSpeciesSupport$4 = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return V8_VERSION$1 >= 51 || !fails$7(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES$1] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); +}; + +var $$c = _export; +var isArray$1 = isArray$3; +var isConstructor$1 = isConstructor$4; +var isObject$3 = isObject$i; +var toAbsoluteIndex = toAbsoluteIndex$3; +var lengthOfArrayLike$3 = lengthOfArrayLike$8; +var toIndexedObject$2 = toIndexedObject$9; +var createProperty$2 = createProperty$4; +var wellKnownSymbol$3 = wellKnownSymbol$k; +var arrayMethodHasSpeciesSupport$3 = arrayMethodHasSpeciesSupport$4; +var nativeSlice = arraySlice$3; + +var HAS_SPECIES_SUPPORT$2 = arrayMethodHasSpeciesSupport$3('slice'); + +var SPECIES = wellKnownSymbol$3('species'); +var $Array$1 = Array; +var max = Math.max; + +// `Array.prototype.slice` method +// https://tc39.es/ecma262/#sec-array.prototype.slice +// fallback for not array-like ES3 strings and DOM objects +$$c({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$2 }, { + slice: function slice(start, end) { + var O = toIndexedObject$2(this); + var length = lengthOfArrayLike$3(O); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible + var Constructor, result, n; + if (isArray$1(O)) { + Constructor = O.constructor; + // cross-realm fallback + if (isConstructor$1(Constructor) && (Constructor === $Array$1 || isArray$1(Constructor.prototype))) { + Constructor = undefined; + } else if (isObject$3(Constructor)) { + Constructor = Constructor[SPECIES]; + if (Constructor === null) Constructor = undefined; + } + if (Constructor === $Array$1 || Constructor === undefined) { + return nativeSlice(O, k, fin); + } + } + result = new (Constructor === undefined ? $Array$1 : Constructor)(max(fin - k, 0)); + for (n = 0; k < fin; k++, n++) if (k in O) createProperty$2(result, n, O[k]); + result.length = n; + return result; + } +}); + +var fails$6 = fails$p; + +var arrayMethodIsStrict$3 = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails$6(function () { + // eslint-disable-next-line no-useless-call -- required for testing + method.call(null, argument || function () { return 1; }, 1); + }); +}; + +var $$b = _export; +var uncurryThis$4 = functionUncurryThis; +var IndexedObject = indexedObject; +var toIndexedObject$1 = toIndexedObject$9; +var arrayMethodIsStrict$2 = arrayMethodIsStrict$3; + +var nativeJoin = uncurryThis$4([].join); + +var ES3_STRINGS = IndexedObject !== Object; +var FORCED$2 = ES3_STRINGS || !arrayMethodIsStrict$2('join', ','); + +// `Array.prototype.join` method +// https://tc39.es/ecma262/#sec-array.prototype.join +$$b({ target: 'Array', proto: true, forced: FORCED$2 }, { + join: function join(separator) { + return nativeJoin(toIndexedObject$1(this), separator === undefined ? ',' : separator); + } +}); + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise */ + + +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +var $$a = _export; +var toObject$3 = toObject$8; +var nativeKeys = objectKeys$3; +var fails$5 = fails$p; + +var FAILS_ON_PRIMITIVES = fails$5(function () { nativeKeys(1); }); + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +$$a({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { + keys: function keys(it) { + return nativeKeys(toObject$3(it)); + } +}); + +var isObject$2 = isObject$i; +var classof = classofRaw$2; +var wellKnownSymbol$2 = wellKnownSymbol$k; + +var MATCH$1 = wellKnownSymbol$2('match'); + +// `IsRegExp` abstract operation +// https://tc39.es/ecma262/#sec-isregexp +var isRegexp = function (it) { + var isRegExp; + return isObject$2(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof(it) === 'RegExp'); +}; + +var isRegExp = isRegexp; + +var $TypeError$2 = TypeError; + +var notARegexp = function (it) { + if (isRegExp(it)) { + throw new $TypeError$2("The method doesn't accept regular expressions"); + } return it; +}; + +var wellKnownSymbol$1 = wellKnownSymbol$k; + +var MATCH = wellKnownSymbol$1('match'); + +var correctIsRegexpLogic = function (METHOD_NAME) { + var regexp = /./; + try { + '/./'[METHOD_NAME](regexp); + } catch (error1) { + try { + regexp[MATCH] = false; + return '/./'[METHOD_NAME](regexp); + } catch (error2) { /* empty */ } + } return false; +}; + +var $$9 = _export; +var uncurryThis$3 = functionUncurryThisClause; +var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; +var toLength = toLength$2; +var toString$2 = toString$5; +var notARegExp = notARegexp; +var requireObjectCoercible$1 = requireObjectCoercible$5; +var correctIsRegExpLogic = correctIsRegexpLogic; + +// eslint-disable-next-line es/no-string-prototype-startswith -- safe +var nativeStartsWith = uncurryThis$3(''.startsWith); +var stringSlice = uncurryThis$3(''.slice); +var min = Math.min; + +var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith'); +// https://github.com/zloirock/core-js/pull/702 +var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () { + var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith'); + return descriptor && !descriptor.writable; +}(); + +// `String.prototype.startsWith` method +// https://tc39.es/ecma262/#sec-string.prototype.startswith +$$9({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, { + startsWith: function startsWith(searchString /* , position = 0 */) { + var that = toString$2(requireObjectCoercible$1(this)); + notARegExp(searchString); + var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length)); + var search = toString$2(searchString); + return nativeStartsWith + ? nativeStartsWith(that, search, index) + : stringSlice(that, index, index + search.length) === search; + } +}); + +var $forEach = arrayIteration.forEach; +var arrayMethodIsStrict$1 = arrayMethodIsStrict$3; + +var STRICT_METHOD$1 = arrayMethodIsStrict$1('forEach'); + +// `Array.prototype.forEach` method implementation +// https://tc39.es/ecma262/#sec-array.prototype.foreach +var arrayForEach = !STRICT_METHOD$1 ? function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); +// eslint-disable-next-line es/no-array-prototype-foreach -- safe +} : [].forEach; + +var global$1 = global$k; +var DOMIterables = domIterables; +var DOMTokenListPrototype = domTokenListPrototype; +var forEach = arrayForEach; +var createNonEnumerableProperty = createNonEnumerableProperty$5; + +var handlePrototype = function (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { + createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach); + } catch (error) { + CollectionPrototype.forEach = forEach; + } +}; + +for (var COLLECTION_NAME in DOMIterables) { + if (DOMIterables[COLLECTION_NAME]) { + handlePrototype(global$1[COLLECTION_NAME] && global$1[COLLECTION_NAME].prototype); + } +} + +handlePrototype(DOMTokenListPrototype); + +var DESCRIPTORS$1 = descriptors; +var fails$4 = fails$p; +var uncurryThis$2 = functionUncurryThis; +var objectGetPrototypeOf = objectGetPrototypeOf$1; +var objectKeys = objectKeys$3; +var toIndexedObject = toIndexedObject$9; +var $propertyIsEnumerable = objectPropertyIsEnumerable.f; + +var propertyIsEnumerable = uncurryThis$2($propertyIsEnumerable); +var push$1 = uncurryThis$2([].push); + +// in some IE versions, `propertyIsEnumerable` returns incorrect result on integer keys +// of `null` prototype objects +var IE_BUG = DESCRIPTORS$1 && fails$4(function () { + // eslint-disable-next-line es/no-object-create -- safe + var O = Object.create(null); + O[2] = 2; + return !propertyIsEnumerable(O, 2); +}); + +// `Object.{ entries, values }` methods implementation +var createMethod$1 = function (TO_ENTRIES) { + return function (it) { + var O = toIndexedObject(it); + var keys = objectKeys(O); + var IE_WORKAROUND = IE_BUG && objectGetPrototypeOf(O) === null; + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!DESCRIPTORS$1 || (IE_WORKAROUND ? key in O : propertyIsEnumerable(O, key))) { + push$1(result, TO_ENTRIES ? [key, O[key]] : O[key]); + } + } + return result; + }; +}; + +var objectToArray = { + // `Object.entries` method + // https://tc39.es/ecma262/#sec-object.entries + entries: createMethod$1(true), + // `Object.values` method + // https://tc39.es/ecma262/#sec-object.values + values: createMethod$1(false) +}; + +var $$8 = _export; +var $entries = objectToArray.entries; + +// `Object.entries` method +// https://tc39.es/ecma262/#sec-object.entries +$$8({ target: 'Object', stat: true }, { + entries: function entries(O) { + return $entries(O); + } +}); + +function defined(x) { + return x != null && !Number.isNaN(x); +} + +function ascendingDefined(a, b) { + return +defined(b) - +defined(a) || ascending(a, b); +} + +function finite(x) { + return isFinite(x) ? x : NaN; +} + +function positive(x) { + return x > 0 && isFinite(x) ? x : NaN; +} + +function negative(x) { + return x < 0 && isFinite(x) ? x : NaN; +} + +const re = /^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/; + +function parse(string, fallback) { + if (!re.test(string += "")) return typeof fallback === "function" ? fallback(string) : fallback; + return new Date(string); +} + +const timeIntervals = new Map([ + ["second", timeSecond], + ["minute", timeMinute], + ["hour", timeHour], + ["day", timeDay], + ["week", timeWeek], + ["month", timeMonth], + ["quarter", timeMonth.every(3)], + ["half", timeMonth.every(6)], + ["year", timeYear], + ["monday", timeMonday], + ["tuesday", timeTuesday], + ["wednesday", timeWednesday], + ["thursday", timeThursday], + ["friday", timeFriday], + ["saturday", timeSaturday], + ["sunday", timeSunday] +]); + +const utcIntervals = new Map([ + ["second", utcSecond], + ["minute", utcMinute], + ["hour", utcHour], + ["day", utcDay], + ["week", utcWeek], + ["month", utcMonth], + ["quarter", utcMonth.every(3)], + ["half", utcMonth.every(6)], + ["year", utcYear], + ["monday", utcMonday], + ["tuesday", utcTuesday], + ["wednesday", utcWednesday], + ["thursday", utcThursday], + ["friday", utcFriday], + ["saturday", utcSaturday], + ["sunday", utcSunday] +]); + +function maybeTimeInterval(interval) { + const i = timeIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; +} + +function maybeUtcInterval(interval) { + const i = utcIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; +} + +// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray +const TypedArray = Object.getPrototypeOf(Uint8Array); +const objectToString = Object.prototype.toString; +const constant = (x) => () => x; + +// If the values are specified as a typed array, no coercion is required. +function coerceNumbers(values) { + return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array); +} + +// Unlike Mark’s number, here we want to convert null and undefined to NaN since +// the result will be stored in a Float64Array and we don’t want null to be +// coerced to zero. We use Number instead of unary + to allow BigInt coercion. +function coerceNumber(x) { + return x == null ? NaN : Number(x); +} + +function coerceDates(values) { + return map(values, coerceDate); +} + +// When coercing strings to dates, we only want to allow the ISO 8601 format +// since the built-in string parsing of the Date constructor varies across +// browsers. (In the future, this could be made more liberal if desired, though +// it is still generally preferable to do date parsing yourself explicitly, +// rather than rely on Plot.) Any non-string values are coerced to number first +// and treated as milliseconds since UNIX epoch. +function coerceDate(x) { + return x instanceof Date && !isNaN(x) + ? x + : typeof x === "string" + ? parse(x) + : x == null || isNaN((x = +x)) + ? undefined + : new Date(x); +} + +// Promotes the specified data to an array as needed. +function arrayify(data) { + return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data); +} + +// An optimization of type.from(values, f): if the given values are already an +// instanceof the desired array type, the faster values.map method is used. +function map(values, f, type = Array) { + return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f); +} + +// An optimization of type.from(values): if the given values are already an +// instanceof the desired array type, the faster values.slice method is used. +function slice(values, type = Array) { + return values instanceof type ? values.slice() : type.from(values); +} + +// Disambiguates an options object (e.g., {y: "x2"}) from a primitive value. +function isObject$1(option) { + return option?.toString === objectToString; +} + +// Disambiguates a scale options object (e.g., {color: {type: "linear"}}) from +// some other option (e.g., {color: "red"}). When creating standalone legends, +// this is used to test whether a scale is defined; this should be consistent +// with inferScaleType when there are no channels associated with the scale, and +// if this returns true, then normalizeScale must return non-null. +function isScaleOptions(option) { + return isObject$1(option) && (option.type !== undefined || option.domain !== undefined); +} + +// If interval is not nullish, converts interval shorthand such as a number (for +// multiples) or a time interval name (such as “day”) to a {floor, offset, +// range} object similar to a D3 time interval. +function maybeInterval(interval, type) { + if (interval == null) return; + if (typeof interval === "number") { + if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval; + const n = Math.abs(interval); + return interval < 0 + ? { + floor: (d) => Math.floor(d * n) / n, + offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity + range: (lo, hi) => range(Math.ceil(lo * n), hi * n).map((x) => x / n) + } + : { + floor: (d) => Math.floor(d / n) * n, + offset: (d) => d + n, // note: no optional step for simplicity + range: (lo, hi) => range(Math.ceil(lo / n), hi / n).map((x) => x * n) + }; + } + if (typeof interval === "string") return (type === "time" ? maybeTimeInterval : maybeUtcInterval)(interval); + if (typeof interval.floor !== "function") throw new Error("invalid interval; missing floor method"); + if (typeof interval.offset !== "function") throw new Error("invalid interval; missing offset method"); + return interval; +} + +// Like maybeInterval, but requires a range method too. +function maybeRangeInterval(interval, type) { + interval = maybeInterval(interval, type); + if (interval && typeof interval.range !== "function") throw new Error("invalid interval: missing range method"); + return interval; +} + +// Like maybeRangeInterval, but requires a ceil method too. +function maybeNiceInterval(interval, type) { + interval = maybeRangeInterval(interval, type); + if (interval && typeof interval.ceil !== "function") throw new Error("invalid interval: missing ceil method"); + return interval; +} + +function isOrdinal(values) { + for (const value of values) { + if (value == null) continue; + const type = typeof value; + return type === "string" || type === "boolean"; + } +} + +function isTemporal(values) { + for (const value of values) { + if (value == null) continue; + return value instanceof Date; + } +} + +// Are these strings that might represent dates? This is stricter than ISO 8601 +// because we want to ignore false positives on numbers; for example, the string +// "1192" is more likely to represent a number than a date even though it is +// valid ISO 8601 representing 1192-01-01. +function isTemporalString(values) { + for (const value of values) { + if (value == null) continue; + return typeof value === "string" && isNaN(value) && parse(value); + } +} + +// Are these strings that might represent numbers? This is stricter than +// coercion because we want to ignore false positives on e.g. empty strings. +function isNumericString(values) { + for (const value of values) { + if (value == null) continue; + if (typeof value !== "string") return false; + if (!value.trim()) continue; + return !isNaN(value); + } +} + +function isNoneish(value) { + return value == null || isNone(value); +} + +function isNone(value) { + return /^\s*none\s*$/i.test(value); +} + +// Like a sort comparator, returns a positive value if the given array of values +// is in ascending order, a negative value if the values are in descending +// order. Assumes monotonicity; only tests the first and last values. +function orderof(values) { + if (values == null) return; + const first = values[0]; + const last = values[values.length - 1]; + return descending(first, last); +} + +// Positional scales have associated axes, and for ordinal data, a point or band +// scale is used instead of an ordinal scale. +const position = Symbol("position"); + +// Color scales default to the turbo interpolator for quantitative data, and to +// the Tableau10 scheme for ordinal data. Color scales may also have an +// associated legend. +const color = Symbol("color"); + +// Radius scales default to the sqrt type, have a default range of [0, 3], and a +// default domain from 0 to the median first quartile of associated channels. +const radius = Symbol("radius"); + +// Length scales default to the linear type, have a default range of [0, 12], +// and a default domain from 0 to the median median of associated channels. +const length = Symbol("length"); + +// Opacity scales have a default range of [0, 1], and a default domain from 0 to +// the maximum value of associated channels. +const opacity = Symbol("opacity"); + +// Symbol scales have a default range of categorical symbols. +const symbol = Symbol("symbol"); + +// TODO Rather than hard-coding the list of known scale names, collect the names +// and categories for each plot specification, so that custom marks can register +// custom scales. +const registry = new Map([ + ["x", position], + ["y", position], + ["fx", position], + ["fy", position], + ["r", radius], + ["color", color], + ["opacity", opacity], + ["symbol", symbol], + ["length", length] +]); + +const sqrt3 = Math.sqrt(3); +const sqrt4_3 = 2 / sqrt3; + +const symbolHexagon = { + draw(context, size) { + const rx = Math.sqrt(size / Math.PI), + ry = rx * sqrt4_3, + hy = ry / 2; + context.moveTo(0, ry); + context.lineTo(rx, hy); + context.lineTo(rx, -hy); + context.lineTo(0, -ry); + context.lineTo(-rx, -hy); + context.lineTo(-rx, hy); + context.closePath(); + } +}; + +const symbols = new Map([ + ["asterisk", symbolAsterisk], + ["circle", symbolCircle], + ["cross", symbolCross], + ["diamond", symbolDiamond], + ["diamond2", symbolDiamond2], + ["hexagon", symbolHexagon], + ["plus", symbolPlus], + ["square", symbolSquare], + ["square2", symbolSquare2], + ["star", symbolStar], + ["times", symbolTimes], + ["triangle", symbolTriangle], + ["triangle2", symbolTriangle2], + ["wye", symbolWye] +]); + +function isSymbolObject(value) { + return value && typeof value.draw === "function"; +} + +function maybeSymbol(symbol) { + if (symbol == null || isSymbolObject(symbol)) return symbol; + const value = symbols.get(`${symbol}`.toLowerCase()); + if (value) return value; + throw new Error(`invalid symbol: ${symbol}`); +} + +function warn(message) { + console.warn(message); +} + +const ordinalSchemes = new Map([ + // categorical + ["accent", schemeAccent], + ["category10", schemeCategory10], + ["dark2", schemeDark2], + ["paired", schemePaired], + ["pastel1", schemePastel1], + ["pastel2", schemePastel2], + ["set1", schemeSet1], + ["set2", schemeSet2], + ["set3", schemeSet3], + ["tableau10", schemeTableau10], + + // diverging + ["brbg", scheme11(schemeBrBG, interpolateBrBG)], + ["prgn", scheme11(schemePRGn, interpolatePRGn)], + ["piyg", scheme11(schemePiYG, interpolatePiYG)], + ["puor", scheme11(schemePuOr, interpolatePuOr)], + ["rdbu", scheme11(schemeRdBu, interpolateRdBu)], + ["rdgy", scheme11(schemeRdGy, interpolateRdGy)], + ["rdylbu", scheme11(schemeRdYlBu, interpolateRdYlBu)], + ["rdylgn", scheme11(schemeRdYlGn, interpolateRdYlGn)], + ["spectral", scheme11(schemeSpectral, interpolateSpectral)], + + // reversed diverging (for temperature data) + ["burd", scheme11r(schemeRdBu, interpolateRdBu)], + ["buylrd", scheme11r(schemeRdYlBu, interpolateRdYlBu)], + + // sequential (single-hue) + ["blues", scheme9(schemeBlues, interpolateBlues)], + ["greens", scheme9(schemeGreens, interpolateGreens)], + ["greys", scheme9(schemeGreys, interpolateGreys)], + ["oranges", scheme9(schemeOranges, interpolateOranges)], + ["purples", scheme9(schemePurples, interpolatePurples)], + ["reds", scheme9(schemeReds, interpolateReds)], + + // sequential (multi-hue) + ["turbo", schemei(interpolateTurbo)], + ["viridis", schemei(interpolateViridis)], + ["magma", schemei(interpolateMagma)], + ["inferno", schemei(interpolateInferno)], + ["plasma", schemei(interpolatePlasma)], + ["cividis", schemei(interpolateCividis)], + ["cubehelix", schemei(interpolateCubehelixDefault)], + ["warm", schemei(interpolateWarm)], + ["cool", schemei(interpolateCool)], + ["bugn", scheme9(schemeBuGn, interpolateBuGn)], + ["bupu", scheme9(schemeBuPu, interpolateBuPu)], + ["gnbu", scheme9(schemeGnBu, interpolateGnBu)], + ["orrd", scheme9(schemeOrRd, interpolateOrRd)], + ["pubu", scheme9(schemePuBu, interpolatePuBu)], + ["pubugn", scheme9(schemePuBuGn, interpolatePuBuGn)], + ["purd", scheme9(schemePuRd, interpolatePuRd)], + ["rdpu", scheme9(schemeRdPu, interpolateRdPu)], + ["ylgn", scheme9(schemeYlGn, interpolateYlGn)], + ["ylgnbu", scheme9(schemeYlGnBu, interpolateYlGnBu)], + ["ylorbr", scheme9(schemeYlOrBr, interpolateYlOrBr)], + ["ylorrd", scheme9(schemeYlOrRd, interpolateYlOrRd)], + + // cyclical + ["rainbow", schemeicyclical(interpolateRainbow)], + ["sinebow", schemeicyclical(interpolateSinebow)] +]); + +function scheme9(scheme, interpolate) { + return ({length: n}) => { + if (n === 1) return [scheme[3][1]]; // favor midpoint + if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker + n = Math.max(3, Math.floor(n)); + return n > 9 ? quantize(interpolate, n) : scheme[n]; + }; +} + +function scheme11(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? quantize(interpolate, n) : scheme[n]; + }; +} + +function scheme11r(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse(); + }; +} + +function schemei(interpolate) { + return ({length: n}) => quantize(interpolate, Math.max(2, Math.floor(n))); +} + +function schemeicyclical(interpolate) { + return ({length: n}) => quantize(interpolate, Math.floor(n) + 1).slice(0, -1); +} + +function ordinalScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`); + return ordinalSchemes.get(s); +} + +function ordinalRange(scheme, length) { + const s = ordinalScheme(scheme); + const r = typeof s === "function" ? s({length}) : s; + return r.length !== length ? r.slice(0, length) : r; +} + +// If the specified domain contains only booleans (ignoring null and undefined), +// returns a corresponding range where false is mapped to the low color and true +// is mapped to the high color of the specified scheme. +function maybeBooleanRange(domain, scheme = "greys") { + const range = new Set(); + const [f, t] = ordinalRange(scheme, 2); + for (const value of domain) { + if (value == null) continue; + if (value === true) range.add(t); + else if (value === false) range.add(f); + else return; + } + return [...range]; +} + +const quantitativeSchemes = new Map([ + // diverging + ["brbg", interpolateBrBG], + ["prgn", interpolatePRGn], + ["piyg", interpolatePiYG], + ["puor", interpolatePuOr], + ["rdbu", interpolateRdBu], + ["rdgy", interpolateRdGy], + ["rdylbu", interpolateRdYlBu], + ["rdylgn", interpolateRdYlGn], + ["spectral", interpolateSpectral], + + // reversed diverging (for temperature data) + ["burd", (t) => interpolateRdBu(1 - t)], + ["buylrd", (t) => interpolateRdYlBu(1 - t)], + + // sequential (single-hue) + ["blues", interpolateBlues], + ["greens", interpolateGreens], + ["greys", interpolateGreys], + ["purples", interpolatePurples], + ["reds", interpolateReds], + ["oranges", interpolateOranges], + + // sequential (multi-hue) + ["turbo", interpolateTurbo], + ["viridis", interpolateViridis], + ["magma", interpolateMagma], + ["inferno", interpolateInferno], + ["plasma", interpolatePlasma], + ["cividis", interpolateCividis], + ["cubehelix", interpolateCubehelixDefault], + ["warm", interpolateWarm], + ["cool", interpolateCool], + ["bugn", interpolateBuGn], + ["bupu", interpolateBuPu], + ["gnbu", interpolateGnBu], + ["orrd", interpolateOrRd], + ["pubugn", interpolatePuBuGn], + ["pubu", interpolatePuBu], + ["purd", interpolatePuRd], + ["rdpu", interpolateRdPu], + ["ylgnbu", interpolateYlGnBu], + ["ylgn", interpolateYlGn], + ["ylorbr", interpolateYlOrBr], + ["ylorrd", interpolateYlOrRd], + + // cyclical + ["rainbow", interpolateRainbow], + ["sinebow", interpolateSinebow] +]); + +function quantitativeScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`); + return quantitativeSchemes.get(s); +} + +const divergingSchemes = new Set([ + "brbg", + "prgn", + "piyg", + "puor", + "rdbu", + "rdgy", + "rdylbu", + "rdylgn", + "spectral", + "burd", + "buylrd" +]); + +function isDivergingScheme(scheme) { + return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase()); +} + +const flip = (i) => (t) => i(1 - t); +const unit = [0, 1]; + +const interpolators = new Map([ + // numbers + ["number", interpolateNumber], + + // color spaces + ["rgb", interpolateRgb], + ["hsl", interpolateHsl], + ["hcl", interpolateHcl], + ["lab", interpolateLab] +]); + +function maybeInterpolator(interpolate) { + const i = `${interpolate}`.toLowerCase(); + if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`); + return interpolators.get(i); +} + +function createScaleQ( + key, + scale, + channels, + { + type, + nice, + clamp, + zero, + domain = inferAutoDomain(key, channels), + unknown, + round, + scheme, + interval, + range = registry.get(key) === radius + ? inferRadialRange(channels, domain) + : registry.get(key) === length + ? inferLengthRange(channels, domain) + : registry.get(key) === opacity + ? unit + : undefined, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : type === "cyclical" ? "rainbow" : "turbo") + : round + ? interpolateRound + : interpolateNumber, + reverse: reverse$1 + } +) { + interval = maybeRangeInterval(interval, type); + if (type === "cyclical" || type === "sequential") type = "linear"; // shorthand for color schemes + reverse$1 = !!reverse$1; + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + if (interpolate.length === 1) { + if (reverse$1) { + interpolate = flip(interpolate); + reverse$1 = false; + } + if (range === undefined) { + range = Float64Array.from(domain, (_, i) => i / (domain.length - 1)); + if (range.length === 2) range = unit; // optimize common case of [0, 1] + } + scale.interpolate((range === unit ? constant : interpolatePiecewise)(interpolate)); + } else { + scale.interpolate(interpolate); + } + + // If a zero option is specified, we assume that the domain is numeric, and we + // want to ensure that the domain crosses zero. However, note that the domain + // may be reversed (descending) so we shouldn’t assume that the first value is + // smaller than the last; and also it’s possible that the domain has more than + // two values for a “poly” scale. And lastly be careful not to mutate input! + if (zero) { + const [min, max] = extent(domain); + if (min > 0 || max < 0) { + domain = slice(domain); + if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0; + // [2, 1] or [-2, -1] + else domain[0] = 0; // [1, 2] or [-1, -2] + } + } + + if (reverse$1) domain = reverse(domain); + scale.domain(domain).unknown(unknown); + if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain()); + if (range !== undefined) scale.range(range); + if (clamp) scale.clamp(clamp); + return {type, domain, range, scale, interpolate, interval}; +} + +function maybeNice(nice, type) { + return nice === true ? undefined : typeof nice === "number" ? nice : maybeNiceInterval(nice, type); +} + +function createScaleLinear(key, channels, options) { + return createScaleQ(key, scaleLinear(), channels, options); +} + +function createScaleSqrt(key, channels, options) { + return createScalePow(key, channels, {...options, exponent: 0.5}); +} + +function createScalePow(key, channels, {exponent = 1, ...options}) { + return createScaleQ(key, scalePow().exponent(exponent), channels, {...options, type: "pow"}); +} + +function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) { + return createScaleQ(key, scaleLog().base(base), channels, {...options, domain}); +} + +function createScaleSymlog(key, channels, {constant = 1, ...options}) { + return createScaleQ(key, scaleSymlog().constant(constant), channels, options); +} + +function createScaleQuantile( + key, + channels, + { + range, + quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead + n = quantiles, + scheme = "rdylbu", + domain = inferQuantileDomain(channels), + unknown, + interpolate, + reverse + } +) { + if (range === undefined) { + range = + interpolate !== undefined + ? quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } + if (domain.length > 0) { + domain = scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles(); + } + return createScaleThreshold(key, channels, {domain, range, reverse, unknown}); +} + +function createScaleQuantize( + key, + channels, + { + range, + n = range === undefined ? 5 : (range = [...range]).length, + scheme = "rdylbu", + domain = inferAutoDomain(key, channels), + unknown, + interpolate, + reverse + } +) { + const [min, max] = extent(domain); + let thresholds; + if (range === undefined) { + thresholds = ticks(min, max, n); // approximate number of nice, round thresholds + if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound + if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound + n = thresholds.length + 1; + range = + interpolate !== undefined + ? quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } else { + thresholds = quantize(interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range + if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types + } + if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain + return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown}); +} + +function createScaleThreshold( + key, + channels, + { + domain = [0], // explicit thresholds in ascending order + unknown, + scheme = "rdylbu", + interpolate, + range = interpolate !== undefined + ? quantize(interpolate, domain.length + 1) + : registry.get(key) === color + ? ordinalRange(scheme, domain.length + 1) + : undefined, + reverse: reverse$1 + } +) { + domain = arrayify(domain); + const sign = orderof(domain); // preserve descending domain + if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`); + if (reverse$1) range = reverse(range); // domain ascending, so reverse range + return { + type: "threshold", + scale: scaleThreshold(sign < 0 ? reverse(domain) : domain, range === undefined ? [] : range).unknown(unknown), + domain, + range + }; +} + +function isOrdered(domain, sign) { + for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) { + const s = descending(d, (d = domain[i])); + if (s !== 0 && s !== sign) return false; + } + return true; +} + +function createScaleIdentity() { + return {type: "identity", scale: scaleIdentity()}; +} + +function inferDomain$1(channels, f = finite) { + return channels.length + ? [ + min$3(channels, ({value}) => (value === undefined ? value : min$3(value, f))), + max$3(channels, ({value}) => (value === undefined ? value : max$3(value, f))) + ] + : [0, 1]; +} + +function inferAutoDomain(key, channels) { + const type = registry.get(key); + return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain$1)(channels); +} + +function inferZeroDomain(channels) { + return [0, channels.length ? max$3(channels, ({value}) => (value === undefined ? value : max$3(value, finite))) : 1]; +} + +// We don’t want the upper bound of the radial domain to be zero, as this would +// be degenerate, so we ignore nonpositive values. We also don’t want the +// maximum default radius to exceed 30px. +function inferRadialRange(channels, domain) { + const hint = channels.find(({radius}) => radius !== undefined); + if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins + const h25 = quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : quantile(value, 0.25, positive))); + const range = domain.map((d) => 3 * Math.sqrt(d / h25)); + const k = 30 / max$3(range); + return k < 1 ? range.map((r) => r * k) : range; +} + +// We want a length scale’s domain to go from zero to a positive value, and to +// treat negative lengths if any as inverted vectors of equivalent magnitude. We +// also don’t want the maximum default length to exceed 60px. +function inferLengthRange(channels, domain) { + const h50 = median(channels, ({value}) => (value === undefined ? NaN : median(value, Math.abs))); + const range = domain.map((d) => (12 * d) / h50); + const k = 60 / max$3(range); + return k < 1 ? range.map((r) => r * k) : range; +} + +function inferLogDomain(channels) { + for (const {value} of channels) { + if (value !== undefined) { + for (let v of value) { + if (v > 0) return inferDomain$1(channels, positive); + if (v < 0) return inferDomain$1(channels, negative); + } + } + } + return [1, 10]; +} + +function inferQuantileDomain(channels) { + const domain = []; + for (const {value} of channels) { + if (value === undefined) continue; + for (const v of value) domain.push(v); + } + return domain; +} + +function interpolatePiecewise(interpolate) { + return (i, j) => (t) => interpolate(i + t * (j - i)); +} + +function createScaleD( + key, + scale, + transform, + channels, + { + type, + nice, + clamp, + domain = inferDomain$1(channels), + unknown, + pivot = 0, + scheme, + range, + symmetric = true, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : "rdbu") + : interpolateNumber, + reverse + } +) { + pivot = +pivot; + let [min, max] = domain; + if (descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse); + min = Math.min(min, pivot); + max = Math.max(max, pivot); + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + + // If an explicit range is specified, promote it to a piecewise interpolator. + if (range !== undefined) { + interpolate = + interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : piecewise(interpolate, range); + } + + // Reverse before normalization. + if (reverse) interpolate = flip(interpolate); + + // Normalize the interpolator for symmetric difference around the pivot. + if (symmetric) { + const mid = transform.apply(pivot); + const mindelta = mid - transform.apply(min); + const maxdelta = transform.apply(max) - mid; + if (mindelta < maxdelta) min = transform.invert(mid - maxdelta); + else if (mindelta > maxdelta) max = transform.invert(mid + mindelta); + } + + scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate); + if (clamp) scale.clamp(clamp); + if (nice) scale.nice(nice); + return {type, domain: [min, max], pivot, interpolate, scale}; +} + +function createScaleDiverging(key, channels, options) { + return createScaleD(key, scaleDiverging(), transformIdentity, channels, options); +} + +function createScaleDivergingSqrt(key, channels, options) { + return createScaleDivergingPow(key, channels, {...options, exponent: 0.5}); +} + +function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) { + return createScaleD(key, scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, { + ...options, + type: "diverging-pow" + }); +} + +function createScaleDivergingLog( + key, + channels, + {base = 10, pivot = 1, domain = inferDomain$1(channels, pivot < 0 ? negative : positive), ...options} +) { + return createScaleD(key, scaleDivergingLog().base((base = +base)), transformLog, channels, { + domain, + pivot, + ...options + }); +} + +function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) { + return createScaleD( + key, + scaleDivergingSymlog().constant((constant = +constant)), + transformSymlog(constant), + channels, + options + ); +} + +const transformIdentity = { + apply(x) { + return x; + }, + invert(x) { + return x; + } +}; + +const transformLog = { + apply: Math.log, + invert: Math.exp +}; + +const transformSqrt = { + apply(x) { + return Math.sign(x) * Math.sqrt(Math.abs(x)); + }, + invert(x) { + return Math.sign(x) * (x * x); + } +}; + +function transformPow(exponent) { + return exponent === 0.5 + ? transformSqrt + : { + apply(x) { + return Math.sign(x) * Math.pow(Math.abs(x), exponent); + }, + invert(x) { + return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent); + } + }; +} + +function transformSymlog(constant) { + return { + apply(x) { + return Math.sign(x) * Math.log1p(Math.abs(x / constant)); + }, + invert(x) { + return Math.sign(x) * Math.expm1(Math.abs(x)) * constant; + } + }; +} + +function createScaleT(key, scale, channels, options) { + return createScaleQ(key, scale, channels, options); +} + +function createScaleTime(key, channels, options) { + return createScaleT(key, scaleTime(), channels, options); +} + +function createScaleUtc(key, channels, options) { + return createScaleT(key, scaleUtc(), channels, options); +} + +// This denotes an implicitly ordinal color scale: the scale type was not set, +// but the associated values are strings or booleans. If the associated defined +// values are entirely boolean, the range will default to greys. You can opt out +// of this by setting the type explicitly. +const ordinalImplicit = Symbol("ordinal"); + +function createScaleO(key, scale, channels, {type, interval, domain, range, reverse: reverse$1, hint}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + if (type === "categorical" || type === ordinalImplicit) type = "ordinal"; // shorthand for color schemes + if (reverse$1) domain = reverse(domain); + scale.domain(domain); + if (range !== undefined) { + // If the range is specified as a function, pass it the domain. + if (typeof range === "function") range = range(domain); + scale.range(range); + } + return {type, domain, range, scale, hint, interval}; +} + +function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + let hint; + if (registry.get(key) === symbol) { + hint = inferSymbolHint(channels); + range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol); + } else if (registry.get(key) === color) { + if (range === undefined && (type === "ordinal" || type === ordinalImplicit)) { + range = maybeBooleanRange(domain, scheme); + if (range !== undefined) scheme = undefined; // Don’t re-apply scheme. + } + if (scheme === undefined && range === undefined) { + scheme = type === "ordinal" ? "turbo" : "tableau10"; + } + if (scheme !== undefined) { + if (range !== undefined) { + const interpolate = quantitativeScheme(scheme); + const t0 = range[0], + d = range[1] - range[0]; + range = ({length: n}) => quantize((t) => interpolate(t0 + d * t), n); + } else { + range = ordinalScheme(scheme); + } + } + } + if (unknown === scaleImplicit) { + throw new Error(`implicit unknown on ${key} scale is not supported`); + } + return createScaleO(key, scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint}); +} + +function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) { + return maybeRound(scalePoint().align(align).padding(padding), channels, options, key); +} + +function createScaleBand( + key, + channels, + { + align = 0.5, + padding = 0.1, + paddingInner = padding, + paddingOuter = key === "fx" || key === "fy" ? 0 : padding, + ...options + } +) { + return maybeRound( + scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter), + channels, + options, + key + ); +} + +function maybeRound(scale, channels, options, key) { + let {round} = options; + if (round !== undefined) scale.round((round = !!round)); + scale = createScaleO(key, scale, channels, options); + scale.round = round; // preserve for autoScaleRound + return scale; +} + +function inferDomain(channels, interval, key) { + const values = new InternSet(); + for (const {value, domain} of channels) { + if (domain !== undefined) return domain(); // see channelDomain + if (value === undefined) continue; + for (const v of value) values.add(v); + } + if (interval !== undefined) { + const [min, max] = extent(values).map(interval.floor, interval); + return interval.range(min, interval.offset(max)); + } + if (values.size > 10e3 && registry.get(key) === position) { + throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`); + } + return sort(values, ascendingDefined); +} + +// If all channels provide a consistent hint, propagate it to the scale. +function inferHint(channels, key) { + let value; + for (const {hint} of channels) { + const candidate = hint?.[key]; + if (candidate === undefined) continue; // no hint here + if (value === undefined) value = candidate; + // first hint + else if (value !== candidate) return; // inconsistent hint + } + return value; +} + +function inferSymbolHint(channels) { + return { + fill: inferHint(channels, "fill"), + stroke: inferHint(channels, "stroke") + }; +} + +function inferSymbolRange(hint) { + return isNoneish(hint.fill) ? symbolsStroke : symbolsFill; +} + +function normalizeScale(key, scale, hint) { + return createScale(key, hint === undefined ? undefined : [{hint}], {...scale}); +} + +function createScale(key, channels = [], options = {}) { + const type = inferScaleType(key, channels, options); + + // Warn for common misuses of implicit ordinal scales. We disable this test if + // you specify a scale interval or if you set the domain or range explicitly, + // since setting the domain or range (typically with a cardinality of more than + // two) is another indication that you intended for the scale to be ordinal; we + // also disable it for facet scales since these are always band scales. + if ( + options.type === undefined && + options.domain === undefined && + options.range === undefined && + options.interval == null && + key !== "fx" && + key !== "fy" && + isOrdinalScale({type}) + ) { + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isTemporal)) + warn( + `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isTemporalString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isNumericString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${formatScaleType( + type + )}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + } + + options.type = type; // Mutates input! + + // Once the scale type is known, coerce the associated channel values and any + // explicitly-specified domain to the expected type. + switch (type) { + case "diverging": + case "diverging-sqrt": + case "diverging-pow": + case "diverging-log": + case "diverging-symlog": + case "cyclical": + case "sequential": + case "linear": + case "sqrt": + case "threshold": + case "quantile": + case "pow": + case "log": + case "symlog": + options = coerceType(channels, options, coerceNumbers); + break; + case "identity": + switch (registry.get(key)) { + case position: + options = coerceType(channels, options, coerceNumbers); + break; + case symbol: + options = coerceType(channels, options, coerceSymbols); + break; + } + break; + case "utc": + case "time": + options = coerceType(channels, options, coerceDates); + break; + } + + switch (type) { + case "diverging": + return createScaleDiverging(key, channels, options); + case "diverging-sqrt": + return createScaleDivergingSqrt(key, channels, options); + case "diverging-pow": + return createScaleDivergingPow(key, channels, options); + case "diverging-log": + return createScaleDivergingLog(key, channels, options); + case "diverging-symlog": + return createScaleDivergingSymlog(key, channels, options); + case "categorical": + case "ordinal": + case ordinalImplicit: + return createScaleOrdinal(key, channels, options); + case "cyclical": + case "sequential": + case "linear": + return createScaleLinear(key, channels, options); + case "sqrt": + return createScaleSqrt(key, channels, options); + case "threshold": + return createScaleThreshold(key, channels, options); + case "quantile": + return createScaleQuantile(key, channels, options); + case "quantize": + return createScaleQuantize(key, channels, options); + case "pow": + return createScalePow(key, channels, options); + case "log": + return createScaleLog(key, channels, options); + case "symlog": + return createScaleSymlog(key, channels, options); + case "utc": + return createScaleUtc(key, channels, options); + case "time": + return createScaleTime(key, channels, options); + case "point": + return createScalePoint(key, channels, options); + case "band": + return createScaleBand(key, channels, options); + case "identity": + return registry.get(key) === position ? createScaleIdentity() : {type: "identity"}; + case undefined: + return; + default: + throw new Error(`unknown scale type: ${type}`); + } +} + +function formatScaleType(type) { + return typeof type === "symbol" ? type.description : type; +} + +// A special type symbol when the x and y scales are replaced with a projection. +const typeProjection = {toString: () => "projection"}; + +function inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) { + // The facet scales are always band scales; this cannot be changed. + if (key === "fx" || key === "fy") return "band"; + + // If a projection is specified, the x- and y-scales are disabled; these + // channels will be projected rather than scaled. (But still check that none + // of the associated channels are incompatible with a projection.) + if ((key === "x" || key === "y") && projection != null) type = typeProjection; + + // If a channel dictates a scale type, make sure that it is consistent with + // the user-specified scale type (if any) and all other channels. For example, + // barY requires x to be a band scale and disallows any other scale type. + for (const {type: t} of channels) { + if (t === undefined) continue; + else if (type === undefined) type = t; + else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`); + } + + // If the scale, a channel, or user specified a (consistent) type, return it. + if (type === typeProjection) return; + if (type !== undefined) return type; + + // If there’s no data (and no type) associated with this scale, don’t create a scale. + if (domain === undefined && !channels.some(({value}) => value !== undefined)) return; + + // Some scales have default types. + const kind = registry.get(key); + if (kind === radius) return "sqrt"; + if (kind === opacity || kind === length) return "linear"; + if (kind === symbol) return "ordinal"; + + // If the domain or range has more than two values, assume it’s ordinal. You + // can still use a “piecewise” (or “polylinear”) scale, but you must set the + // type explicitly. + if ((domain || range || []).length > 2) return asOrdinalType(kind); + + // Otherwise, infer the scale type from the data! Prefer the domain, if + // present, over channels. (The domain and channels should be consistently + // typed, and the domain is more explicit and typically much smaller.) We only + // check the first defined value for expedience and simplicity; we expect + // that the types are consistent. + if (domain !== undefined) { + if (isOrdinal(domain)) return asOrdinalType(kind); + if (isTemporal(domain)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; + } + + // If any channel is ordinal or temporal, it takes priority. + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isOrdinal)) return asOrdinalType(kind); + if (values.some(isTemporal)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; +} + +// Positional scales default to a point scale instead of an ordinal scale. +function asOrdinalType(kind) { + switch (kind) { + case position: + return "point"; + case color: + return ordinalImplicit; + default: + return "ordinal"; + } +} + +function isOrdinalScale({type}) { + return type === "ordinal" || type === "point" || type === "band" || type === ordinalImplicit; +} + +// Mutates channel.value! +function coerceType(channels, {domain, ...options}, coerceValues) { + for (const c of channels) { + if (c.value !== undefined) { + c.value = coerceValues(c.value); + } + } + return { + domain: domain === undefined ? domain : coerceValues(domain), + ...options + }; +} + +function coerceSymbols(values) { + return map(values, maybeSymbol); +} + +function scale(options = {}) { + let scale; + for (const key in options) { + if (!registry.has(key)) continue; // ignore unknown properties + if (!isScaleOptions(options[key])) continue; // e.g., ignore {color: "red"} + if (scale !== undefined) throw new Error("ambiguous scale definition; multiple scales found"); + scale = exposeScale(normalizeScale(key, options[key])); + } + if (scale === undefined) throw new Error("invalid scale definition; no scale found"); + return scale; +} + +// Note: axis- and legend-related properties (such as label, ticks and +// tickFormat) are not included here as they do not affect the scale’s behavior. +function exposeScale({scale, type, domain, range, interpolate, interval, transform, percent, pivot}) { + if (type === "identity") return {type: "identity", apply: (d) => d, invert: (d) => d}; + const unknown = scale.unknown ? scale.unknown() : undefined; + return { + type, + domain: slice(domain), // defensive copy + ...(range !== undefined && {range: slice(range)}), // defensive copy + ...(transform !== undefined && {transform}), + ...(percent && {percent}), // only exposed if truthy + ...(unknown !== undefined && {unknown}), + ...(interval !== undefined && {interval}), + + // quantitative + ...(interpolate !== undefined && {interpolate}), + ...(scale.clamp && {clamp: scale.clamp()}), + + // diverging (always asymmetric; we never want to apply the symmetric transform twice) + ...(pivot !== undefined && {pivot, symmetric: false}), + + // log, diverging-log + ...(scale.base && {base: scale.base()}), + + // pow, diverging-pow + ...(scale.exponent && {exponent: scale.exponent()}), + + // symlog, diverging-symlog + ...(scale.constant && {constant: scale.constant()}), + + // band, point + ...(scale.align && {align: scale.align(), round: scale.round()}), + ...(scale.padding && + (scale.paddingInner + ? {paddingInner: scale.paddingInner(), paddingOuter: scale.paddingOuter()} + : {padding: scale.padding()})), + ...(scale.bandwidth && {bandwidth: scale.bandwidth(), step: scale.step()}), + + // utilities + apply: (t) => scale(t), + ...(scale.invert && {invert: (t) => scale.invert(t)}) + }; +} + +var ScrollDirection; +(function (ScrollDirection) { + ScrollDirection[ScrollDirection["SCROLL_NONE"] = 0] = "SCROLL_NONE"; + ScrollDirection[ScrollDirection["SCROLL_BACKWARD"] = 1] = "SCROLL_BACKWARD"; + ScrollDirection[ScrollDirection["SCROLL_FORWARD"] = 2] = "SCROLL_FORWARD"; +})(ScrollDirection || (ScrollDirection = {})); +var Position; +(function (Position) { + Position[Position["TOP"] = 0] = "TOP"; + Position[Position["RIGHT"] = 1] = "RIGHT"; + Position[Position["BOTTOM"] = 2] = "BOTTOM"; + Position[Position["LEFT"] = 3] = "LEFT"; +})(Position || (Position = {})); +var OPTIONS_DEFAULT_SUBDOMAIN_WIDTH = 10; +var OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT = 10; +var OPTIONS_DEFAULT_SUBDOMAIN_GUTTER = 2; +var OPTIONS_DEFAULT_SUBDOMAIN_RADIUS = 0; +var SCALE_BASE_OPACITY_COLOR = 'red'; + +function normalizedScale(scaleOptions) { + try { + var scaleType = Object.keys(scaleOptions)[0]; + return scale(_defineProperty({}, scaleType, Object.assign(Object.assign({}, scaleOptions[scaleType]), { + clamp: true + }))); + } catch (error) { + return null; + } +} +function scaleStyle(_scale, scaleOptions) { + var styles = {}; + if (scaleOptions.hasOwnProperty('opacity')) { + styles.fill = function () { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + scaleOptions.opacity.baseColor || SCALE_BASE_OPACITY_COLOR + ); + }; + styles['fill-opacity'] = function (d) { + return _scale === null || _scale === void 0 ? void 0 : _scale.apply(d); + }; + } else { + styles.fill = function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + typeof d === 'string' && (d === null || d === void 0 ? void 0 : d.startsWith('#')) ? d : _scale === null || _scale === void 0 ? void 0 : _scale.apply(d) + ); + }; + } + return styles; +} +function applyScaleStyle(elem, _scale, scaleOptions, keyname) { + Object.entries(scaleStyle(_scale, scaleOptions)).forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + prop = _ref2[0], + val = _ref2[1]; + return ( + // eslint-disable-next-line implicit-arrow-linebreak + elem.style(prop, function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + val(keyname ? d[keyname] : d) + ); + }) + ); + }); +} + +var $TypeError$1 = TypeError; +var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991 + +var doesNotExceedSafeInteger$1 = function (it) { + if (it > MAX_SAFE_INTEGER) throw $TypeError$1('Maximum allowed index exceeded'); + return it; +}; + +var $$7 = _export; +var fails$3 = fails$p; +var isArray = isArray$3; +var isObject = isObject$i; +var toObject$2 = toObject$8; +var lengthOfArrayLike$2 = lengthOfArrayLike$8; +var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1; +var createProperty$1 = createProperty$4; +var arraySpeciesCreate = arraySpeciesCreate$2; +var arrayMethodHasSpeciesSupport$2 = arrayMethodHasSpeciesSupport$4; +var wellKnownSymbol = wellKnownSymbol$k; +var V8_VERSION = engineV8Version; + +var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable'); + +// We can't use this feature detection in V8 since it causes +// deoptimization and serious performance degradation +// https://github.com/zloirock/core-js/issues/679 +var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails$3(function () { + var array = []; + array[IS_CONCAT_SPREADABLE] = false; + return array.concat()[0] !== array; +}); + +var isConcatSpreadable = function (O) { + if (!isObject(O)) return false; + var spreadable = O[IS_CONCAT_SPREADABLE]; + return spreadable !== undefined ? !!spreadable : isArray(O); +}; + +var FORCED$1 = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport$2('concat'); + +// `Array.prototype.concat` method +// https://tc39.es/ecma262/#sec-array.prototype.concat +// with adding support of @@isConcatSpreadable and @@species +$$7({ target: 'Array', proto: true, arity: 1, forced: FORCED$1 }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + concat: function concat(arg) { + var O = toObject$2(this); + var A = arraySpeciesCreate(O, 0); + var n = 0; + var i, k, length, len, E; + for (i = -1, length = arguments.length; i < length; i++) { + E = i === -1 ? O : arguments[i]; + if (isConcatSpreadable(E)) { + len = lengthOfArrayLike$2(E); + doesNotExceedSafeInteger(n + len); + for (k = 0; k < len; k++, n++) if (k in E) createProperty$1(A, n, E[k]); + } else { + doesNotExceedSafeInteger(n + 1); + createProperty$1(A, n++, E); + } + } + A.length = n; + return A; + } +}); + +var $$6 = _export; +var call$1 = functionCall; +var aCallable$1 = aCallable$a; +var newPromiseCapabilityModule = newPromiseCapability$2; +var perform = perform$4; +var iterate$1 = iterate$6; +var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration; + +// `Promise.allSettled` method +// https://tc39.es/ecma262/#sec-promise.allsettled +$$6({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + allSettled: function allSettled(iterable) { + var C = this; + var capability = newPromiseCapabilityModule.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aCallable$1(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$1(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$1(promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'fulfilled', value: value }; + --remaining || resolve(values); + }, function (error) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'rejected', reason: error }; + --remaining || resolve(values); + }); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var create = objectCreate; +var defineBuiltInAccessor = defineBuiltInAccessor$3; +var defineBuiltIns = defineBuiltIns$2; +var bind$1 = functionBindContext; +var anInstance = anInstance$4; +var isNullOrUndefined = isNullOrUndefined$7; +var iterate = iterate$6; +var defineIterator = iteratorDefine; +var createIterResultObject = createIterResultObject$3; +var setSpecies = setSpecies$2; +var DESCRIPTORS = descriptors; +var fastKey = internalMetadataExports.fastKey; +var InternalStateModule = internalState; + +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; + +var collectionStrong$1 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + index: create(null), + first: undefined, + last: undefined, + size: 0 + }); + if (!DESCRIPTORS) that.size = 0; + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + // change existing entry + if (entry) { + entry.value = value; + // create new entry + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: undefined, + removed: false + }; + if (!state.first) state.first = entry; + if (previous) previous.next = entry; + if (DESCRIPTORS) state.size++; + else that.size++; + // add to index + if (index !== 'F') state.index[index] = entry; + } return that; + }; + + var getEntry = function (that, key) { + var state = getInternalState(that); + // fast case + var index = fastKey(key); + var entry; + if (index !== 'F') return state.index[index]; + // frozen object case + for (entry = state.first; entry; entry = entry.next) { + if (entry.key === key) return entry; + } + }; + + defineBuiltIns(Prototype, { + // `{ Map, Set }.prototype.clear()` methods + // https://tc39.es/ecma262/#sec-map.prototype.clear + // https://tc39.es/ecma262/#sec-set.prototype.clear + clear: function clear() { + var that = this; + var state = getInternalState(that); + var data = state.index; + var entry = state.first; + while (entry) { + entry.removed = true; + if (entry.previous) entry.previous = entry.previous.next = undefined; + delete data[entry.index]; + entry = entry.next; + } + state.first = state.last = undefined; + if (DESCRIPTORS) state.size = 0; + else that.size = 0; + }, + // `{ Map, Set }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.delete + // https://tc39.es/ecma262/#sec-set.prototype.delete + 'delete': function (key) { + var that = this; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) prev.next = next; + if (next) next.previous = prev; + if (state.first === entry) state.first = next; + if (state.last === entry) state.last = prev; + if (DESCRIPTORS) state.size--; + else that.size--; + } return !!entry; + }, + // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods + // https://tc39.es/ecma262/#sec-map.prototype.foreach + // https://tc39.es/ecma262/#sec-set.prototype.foreach + forEach: function forEach(callbackfn /* , that = undefined */) { + var state = getInternalState(this); + var boundFunction = bind$1(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var entry; + while (entry = entry ? entry.next : state.first) { + boundFunction(entry.value, entry.key, this); + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + } + }, + // `{ Map, Set}.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.has + // https://tc39.es/ecma262/#sec-set.prototype.has + has: function has(key) { + return !!getEntry(this, key); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `Map.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-map.prototype.get + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + // `Map.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-map.prototype.set + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + // `Set.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-set.prototype.add + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (DESCRIPTORS) defineBuiltInAccessor(Prototype, 'size', { + configurable: true, + get: function () { + return getInternalState(this).size; + } + }); + return Constructor; + }, + setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods + // https://tc39.es/ecma262/#sec-map.prototype.entries + // https://tc39.es/ecma262/#sec-map.prototype.keys + // https://tc39.es/ecma262/#sec-map.prototype.values + // https://tc39.es/ecma262/#sec-map.prototype-@@iterator + // https://tc39.es/ecma262/#sec-set.prototype.entries + // https://tc39.es/ecma262/#sec-set.prototype.keys + // https://tc39.es/ecma262/#sec-set.prototype.values + // https://tc39.es/ecma262/#sec-set.prototype-@@iterator + defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: undefined + }); + }, function () { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + // get next entry + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + // or finish the iteration + state.target = undefined; + return createIterResultObject(undefined, true); + } + // return step by kind + if (kind === 'keys') return createIterResultObject(entry.key, false); + if (kind === 'values') return createIterResultObject(entry.value, false); + return createIterResultObject([entry.key, entry.value], false); + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + + // `{ Map, Set }.prototype[@@species]` accessors + // https://tc39.es/ecma262/#sec-get-map-@@species + // https://tc39.es/ecma262/#sec-get-set-@@species + setSpecies(CONSTRUCTOR_NAME); + } +}; + +var collection = collection$2; +var collectionStrong = collectionStrong$1; + +// `Map` constructor +// https://tc39.es/ecma262/#sec-map-objects +collection('Map', function (init) { + return function Map() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionStrong); + +var tryToString = tryToString$5; + +var $TypeError = TypeError; + +var deletePropertyOrThrow$1 = function (O, P) { + if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O)); +}; + +var arraySlice = arraySliceSimple; + +var floor = Math.floor; + +var mergeSort = function (array, comparefn) { + var length = array.length; + var middle = floor(length / 2); + return length < 8 ? insertionSort(array, comparefn) : merge( + array, + mergeSort(arraySlice(array, 0, middle), comparefn), + mergeSort(arraySlice(array, middle), comparefn), + comparefn + ); +}; + +var insertionSort = function (array, comparefn) { + var length = array.length; + var i = 1; + var element, j; + + while (i < length) { + j = i; + element = array[i]; + while (j && comparefn(array[j - 1], element) > 0) { + array[j] = array[--j]; + } + if (j !== i++) array[j] = element; + } return array; +}; + +var merge = function (array, left, right, comparefn) { + var llength = left.length; + var rlength = right.length; + var lindex = 0; + var rindex = 0; + + while (lindex < llength || rindex < rlength) { + array[lindex + rindex] = (lindex < llength && rindex < rlength) + ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] + : lindex < llength ? left[lindex++] : right[rindex++]; + } return array; +}; + +var arraySort = mergeSort; + +var userAgent$1 = engineUserAgent; + +var firefox = userAgent$1.match(/firefox\/(\d+)/i); + +var engineFfVersion = !!firefox && +firefox[1]; + +var UA = engineUserAgent; + +var engineIsIeOrEdge = /MSIE|Trident/.test(UA); + +var userAgent = engineUserAgent; + +var webkit = userAgent.match(/AppleWebKit\/(\d+)\./); + +var engineWebkitVersion = !!webkit && +webkit[1]; + +var $$5 = _export; +var uncurryThis$1 = functionUncurryThis; +var aCallable = aCallable$a; +var toObject$1 = toObject$8; +var lengthOfArrayLike$1 = lengthOfArrayLike$8; +var deletePropertyOrThrow = deletePropertyOrThrow$1; +var toString$1 = toString$5; +var fails$2 = fails$p; +var internalSort = arraySort; +var arrayMethodIsStrict = arrayMethodIsStrict$3; +var FF = engineFfVersion; +var IE_OR_EDGE = engineIsIeOrEdge; +var V8 = engineV8Version; +var WEBKIT = engineWebkitVersion; + +var test = []; +var nativeSort = uncurryThis$1(test.sort); +var push = uncurryThis$1(test.push); + +// IE8- +var FAILS_ON_UNDEFINED = fails$2(function () { + test.sort(undefined); +}); +// V8 bug +var FAILS_ON_NULL = fails$2(function () { + test.sort(null); +}); +// Old WebKit +var STRICT_METHOD = arrayMethodIsStrict('sort'); + +var STABLE_SORT = !fails$2(function () { + // feature detection can be too slow, so check engines versions + if (V8) return V8 < 70; + if (FF && FF > 3) return; + if (IE_OR_EDGE) return true; + if (WEBKIT) return WEBKIT < 603; + + var result = ''; + var code, chr, value, index; + + // generate an array with more 512 elements (Chakra and old V8 fails only in this case) + for (code = 65; code < 76; code++) { + chr = String.fromCharCode(code); + + switch (code) { + case 66: case 69: case 70: case 72: value = 3; break; + case 68: case 71: value = 4; break; + default: value = 2; + } + + for (index = 0; index < 47; index++) { + test.push({ k: chr + index, v: value }); + } + } + + test.sort(function (a, b) { return b.v - a.v; }); + + for (index = 0; index < test.length; index++) { + chr = test[index].k.charAt(0); + if (result.charAt(result.length - 1) !== chr) result += chr; + } + + return result !== 'DGBEFHACIJK'; +}); + +var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT; + +var getSortCompare = function (comparefn) { + return function (x, y) { + if (y === undefined) return -1; + if (x === undefined) return 1; + if (comparefn !== undefined) return +comparefn(x, y) || 0; + return toString$1(x) > toString$1(y) ? 1 : -1; + }; +}; + +// `Array.prototype.sort` method +// https://tc39.es/ecma262/#sec-array.prototype.sort +$$5({ target: 'Array', proto: true, forced: FORCED }, { + sort: function sort(comparefn) { + if (comparefn !== undefined) aCallable(comparefn); + + var array = toObject$1(this); + + if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn); + + var items = []; + var arrayLength = lengthOfArrayLike$1(array); + var itemsLength, index; + + for (index = 0; index < arrayLength; index++) { + if (index in array) push(items, array[index]); + } + + internalSort(items, getSortCompare(comparefn)); + + itemsLength = lengthOfArrayLike$1(items); + index = 0; + + while (index < itemsLength) array[index] = items[index++]; + while (index < arrayLength) deletePropertyOrThrow(array, index++); + + return array; + } +}); + +var $$4 = _export; +var $includes = arrayIncludes.includes; +var fails$1 = fails$p; +var addToUnscopables = addToUnscopables$2; + +// FF99+ bug +var BROKEN_ON_SPARSE = fails$1(function () { + // eslint-disable-next-line es/no-array-prototype-includes -- detection + return !Array(1).includes(); +}); + +// `Array.prototype.includes` method +// https://tc39.es/ecma262/#sec-array.prototype.includes +$$4({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, { + includes: function includes(el /* , fromIndex = 0 */) { + return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('includes'); + +var $$3 = _export; +var $map = arrayIteration.map; +var arrayMethodHasSpeciesSupport$1 = arrayMethodHasSpeciesSupport$4; + +var HAS_SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport$1('map'); + +// `Array.prototype.map` method +// https://tc39.es/ecma262/#sec-array.prototype.map +// with adding support of @@species +$$3({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$1 }, { + map: function map(callbackfn /* , thisArg */) { + return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +var $$2 = _export; +var $filter = arrayIteration.filter; +var arrayMethodHasSpeciesSupport = arrayMethodHasSpeciesSupport$4; + +var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter'); + +// `Array.prototype.filter` method +// https://tc39.es/ecma262/#sec-array.prototype.filter +// with adding support of @@species +$$2({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + filter: function filter(callbackfn /* , thisArg */) { + return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } +}); + +var anObject = anObject$c; +var iteratorClose = iteratorClose$2; + +// call something on iterator step with safe closing on error +var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } +}; + +var bind = functionBindContext; +var call = functionCall; +var toObject = toObject$8; +var callWithSafeIterationClosing = callWithSafeIterationClosing$1; +var isArrayIteratorMethod = isArrayIteratorMethod$2; +var isConstructor = isConstructor$4; +var lengthOfArrayLike = lengthOfArrayLike$8; +var createProperty = createProperty$4; +var getIterator = getIterator$2; +var getIteratorMethod = getIteratorMethod$3; + +var $Array = Array; + +// `Array.from` method implementation +// https://tc39.es/ecma262/#sec-array.from +var arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { + var O = toObject(arrayLike); + var IS_CONSTRUCTOR = isConstructor(this); + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined); + var iteratorMethod = getIteratorMethod(O); + var index = 0; + var length, result, step, iterator, next, value; + // if the target is not iterable or it's an array with the default iterator - use a simple case + if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) { + iterator = getIterator(O, iteratorMethod); + next = iterator.next; + result = IS_CONSTRUCTOR ? new this() : []; + for (;!(step = call(next, iterator)).done; index++) { + value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value; + createProperty(result, index, value); + } + } else { + length = lengthOfArrayLike(O); + result = IS_CONSTRUCTOR ? new this(length) : $Array(length); + for (;length > index; index++) { + value = mapping ? mapfn(O[index], index) : O[index]; + createProperty(result, index, value); + } + } + result.length = index; + return result; +}; + +var $$1 = _export; +var from = arrayFrom; +var checkCorrectnessOfIteration = checkCorrectnessOfIteration$3; + +var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { + // eslint-disable-next-line es/no-array-from -- required for testing + Array.from(iterable); +}); + +// `Array.from` method +// https://tc39.es/ecma262/#sec-array.from +$$1({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { + from: from +}); + +// a string of all valid unicode whitespaces +var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + + '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + +var uncurryThis = functionUncurryThis; +var requireObjectCoercible = requireObjectCoercible$5; +var toString = toString$5; +var whitespaces$1 = whitespaces$2; + +var replace = uncurryThis(''.replace); +var ltrim = RegExp('^[' + whitespaces$1 + ']+'); +var rtrim = RegExp('(^|[^' + whitespaces$1 + '])[' + whitespaces$1 + ']+$'); + +// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation +var createMethod = function (TYPE) { + return function ($this) { + var string = toString(requireObjectCoercible($this)); + if (TYPE & 1) string = replace(string, ltrim, ''); + if (TYPE & 2) string = replace(string, rtrim, '$1'); + return string; + }; +}; + +var stringTrim = { + // `String.prototype.{ trimLeft, trimStart }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimstart + start: createMethod(1), + // `String.prototype.{ trimRight, trimEnd }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimend + end: createMethod(2), + // `String.prototype.trim` method + // https://tc39.es/ecma262/#sec-string.prototype.trim + trim: createMethod(3) +}; + +var PROPER_FUNCTION_NAME = functionName.PROPER; +var fails = fails$p; +var whitespaces = whitespaces$2; + +var non = '\u200B\u0085\u180E'; + +// check that a method works with the correct list +// of whitespaces and has a correct name +var stringTrimForced = function (METHOD_NAME) { + return fails(function () { + return !!whitespaces[METHOD_NAME]() + || non[METHOD_NAME]() !== non + || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME); + }); +}; + +var $ = _export; +var $trim = stringTrim.trim; +var forcedStringTrimMethod = stringTrimForced; + +// `String.prototype.trim` method +// https://tc39.es/ecma262/#sec-string.prototype.trim +$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, { + trim: function trim() { + return $trim(this); + } +}); + +var DEFAULT_SELECTOR$2 = '.ch-subdomain'; + +var DEFAULT_SELECTOR$1 = '.ch-container'; + +var _LegendLite_instances, _LegendLite_buildLegend, _LegendLite_nodeAttrs; +var DEFAULT_SELECTOR = '.ch-plugin-legend-lite'; +var defaultOptions = { + enabled: true, + // Whether to display the legend + itemSelector: null, + width: OPTIONS_DEFAULT_SUBDOMAIN_WIDTH, + height: OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT, + gutter: OPTIONS_DEFAULT_SUBDOMAIN_GUTTER, + radius: OPTIONS_DEFAULT_SUBDOMAIN_RADIUS, + includeBlank: false +}; +var LegendLite = /*#__PURE__*/function () { + function LegendLite(calendar) { + _classCallCheck(this, LegendLite); + _LegendLite_instances.add(this); + this.name = 'LegendLite'; + this.calendar = calendar; + this.root = null; + this.shown = false; + this.options = defaultOptions; + } + _createClass(LegendLite, [{ + key: "setup", + value: function setup(pluginOptions) { + this.options = Object.assign(Object.assign({}, this.options), pluginOptions); + } + }, { + key: "paint", + value: function paint() { + var _this$options = this.options, + enabled = _this$options.enabled, + itemSelector = _this$options.itemSelector; + if (!enabled || itemSelector && select(itemSelector).empty()) { + return this.destroy(); + } + this.shown = true; + this.root = select(itemSelector || this.calendar.options.options.itemSelector); + if (this.root.select(DEFAULT_SELECTOR).empty()) { + this.root = this.root.append('div').attr('class', DEFAULT_SELECTOR.slice(1)); + } else { + this.root = this.root.select(DEFAULT_SELECTOR); + } + var node = __classPrivateFieldGet(this, _LegendLite_instances, "m", _LegendLite_buildLegend).call(this); + this.root.selectAll('*').remove(); + this.root.append(function () { + return node.node(); + }); + return Promise.resolve(); + } + }, { + key: "destroy", + value: function destroy() { + if (this.root !== null) { + this.root.remove(); + this.root = null; + } + return Promise.resolve(); + } + }]); + return LegendLite; +}(); +_LegendLite_instances = new WeakSet(), _LegendLite_buildLegend = function _LegendLite_buildLegend() { + var _this = this; + var node = create$3('svg'); + var scale = normalizedScale(this.calendar.options.options.scale); + var _this$options2 = this.options, + width = _this$options2.width, + height = _this$options2.height, + gutter = _this$options2.gutter, + includeBlank = _this$options2.includeBlank; + var localRange = _toConsumableArray(scale.range); + if (includeBlank) { + localRange.unshift(null); + } + node.attr('class', DEFAULT_SELECTOR$1.slice(1)).attr('width', localRange.length * width + (localRange.length - 1) * gutter).attr('height', height); + node.selectAll('rect').data(localRange).join(function (enter) { + return enter.append('rect').call(function (sc) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + __classPrivateFieldGet(_this, _LegendLite_instances, "m", _LegendLite_nodeAttrs).call(_this, sc, scale) + ); + }); + }, function (update) { + return update.selectAll('rect').call(function (sc) { + return __classPrivateFieldGet(_this, _LegendLite_instances, "m", _LegendLite_nodeAttrs).call(_this, sc, scale); + }); + }); + return node; +}, _LegendLite_nodeAttrs = function _LegendLite_nodeAttrs(selection, scale) { + var _this2 = this; + var _this$options3 = this.options, + width = _this$options3.width, + height = _this$options3.height, + radius = _this$options3.radius, + gutter = _this$options3.gutter; + return selection.attr('width', width).attr('height', height).attr('class', "".concat(DEFAULT_SELECTOR$2.slice(1), "-bg")).attr('rx', radius).attr('ry', radius).attr('x', function (_d, i) { + return i * (width + gutter); + }).attr('y', 0).call(function (element) { + applyScaleStyle(element, scale, _this2.calendar.options.options.scale); + }); +}; + +export { LegendLite as default }; diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.js b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.js new file mode 100644 index 0000000..37ed073 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.js @@ -0,0 +1,6133 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('d3-selection'), require('d3')) : + typeof define === 'function' && define.amd ? define(['d3-selection', 'd3'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.LegendLite = factory(global.d3, global.d3)); +})(this, (function (d3Selection, d3) { 'use strict'; + + function _iterableToArrayLimit(arr, i) { + var _i = null == arr ? null : "undefined" != typeof Symbol && arr[Symbol.iterator] || arr["@@iterator"]; + if (null != _i) { + var _s, + _e, + _x, + _r, + _arr = [], + _n = !0, + _d = !1; + try { + if (_x = (_i = _i.call(arr)).next, 0 === i) { + if (Object(_i) !== _i) return; + _n = !1; + } else for (; !(_n = (_s = _x.call(_i)).done) && (_arr.push(_s.value), _arr.length !== i); _n = !0); + } catch (err) { + _d = !0, _e = err; + } finally { + try { + if (!_n && null != _i.return && (_r = _i.return(), Object(_r) !== _r)) return; + } finally { + if (_d) throw _e; + } + } + return _arr; + } + } + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; + } + function _defineProperty(obj, key, value) { + key = _toPropertyKey(key); + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + return obj; + } + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); + } + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + return arr2; + } + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); + } + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); + } + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + var fails$p = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } + }; + + var fails$o = fails$p; + + // Detect IE8's incomplete defineProperty implementation + var descriptors = !fails$o(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; + }); + + var fails$n = fails$p; + + var functionBindNative = !fails$n(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); + }); + + var NATIVE_BIND$3 = functionBindNative; + + var FunctionPrototype$3 = Function.prototype; + var call$g = FunctionPrototype$3.call; + var uncurryThisWithBind = NATIVE_BIND$3 && FunctionPrototype$3.bind.bind(call$g, call$g); + + var functionUncurryThis = NATIVE_BIND$3 ? uncurryThisWithBind : function (fn) { + return function () { + return call$g.apply(fn, arguments); + }; + }; + + // we can't use just `it == null` since of `document.all` special case + // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec + var isNullOrUndefined$7 = function (it) { + return it === null || it === undefined; + }; + + var isNullOrUndefined$6 = isNullOrUndefined$7; + + var $TypeError$f = TypeError; + + // `RequireObjectCoercible` abstract operation + // https://tc39.es/ecma262/#sec-requireobjectcoercible + var requireObjectCoercible$5 = function (it) { + if (isNullOrUndefined$6(it)) throw new $TypeError$f("Can't call method on " + it); + return it; + }; + + var requireObjectCoercible$4 = requireObjectCoercible$5; + + var $Object$4 = Object; + + // `ToObject` abstract operation + // https://tc39.es/ecma262/#sec-toobject + var toObject$8 = function (argument) { + return $Object$4(requireObjectCoercible$4(argument)); + }; + + var uncurryThis$p = functionUncurryThis; + var toObject$7 = toObject$8; + + var hasOwnProperty = uncurryThis$p({}.hasOwnProperty); + + // `HasOwnProperty` abstract operation + // https://tc39.es/ecma262/#sec-hasownproperty + // eslint-disable-next-line es/no-object-hasown -- safe + var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject$7(it), key); + }; + + var DESCRIPTORS$d = descriptors; + var hasOwn$b = hasOwnProperty_1; + + var FunctionPrototype$2 = Function.prototype; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getDescriptor = DESCRIPTORS$d && Object.getOwnPropertyDescriptor; + + var EXISTS$1 = hasOwn$b(FunctionPrototype$2, 'name'); + // additional protection from minified / mangled / dropped function names + var PROPER = EXISTS$1 && (function something() { /* empty */ }).name === 'something'; + var CONFIGURABLE$1 = EXISTS$1 && (!DESCRIPTORS$d || (DESCRIPTORS$d && getDescriptor(FunctionPrototype$2, 'name').configurable)); + + var functionName = { + EXISTS: EXISTS$1, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE$1 + }; + + var makeBuiltIn$3 = {exports: {}}; + + var documentAll$2 = typeof document == 'object' && document.all; + + // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot + // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing + var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined; + + var documentAll_1 = { + all: documentAll$2, + IS_HTMLDDA: IS_HTMLDDA + }; + + var $documentAll$1 = documentAll_1; + + var documentAll$1 = $documentAll$1.all; + + // `IsCallable` abstract operation + // https://tc39.es/ecma262/#sec-iscallable + var isCallable$m = $documentAll$1.IS_HTMLDDA ? function (argument) { + return typeof argument == 'function' || argument === documentAll$1; + } : function (argument) { + return typeof argument == 'function'; + }; + + var check = function (it) { + return it && it.Math === Math && it; + }; + + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global$k = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + + var global$j = global$k; + + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$7 = Object.defineProperty; + + var defineGlobalProperty$3 = function (key, value) { + try { + defineProperty$7(global$j, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$j[key] = value; + } return value; + }; + + var global$i = global$k; + var defineGlobalProperty$2 = defineGlobalProperty$3; + + var SHARED = '__core-js_shared__'; + var store$3 = global$i[SHARED] || defineGlobalProperty$2(SHARED, {}); + + var sharedStore = store$3; + + var uncurryThis$o = functionUncurryThis; + var isCallable$l = isCallable$m; + var store$2 = sharedStore; + + var functionToString$1 = uncurryThis$o(Function.toString); + + // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper + if (!isCallable$l(store$2.inspectSource)) { + store$2.inspectSource = function (it) { + return functionToString$1(it); + }; + } + + var inspectSource$3 = store$2.inspectSource; + + var global$h = global$k; + var isCallable$k = isCallable$m; + + var WeakMap$1 = global$h.WeakMap; + + var weakMapBasicDetection = isCallable$k(WeakMap$1) && /native code/.test(String(WeakMap$1)); + + var isCallable$j = isCallable$m; + var $documentAll = documentAll_1; + + var documentAll = $documentAll.all; + + var isObject$i = $documentAll.IS_HTMLDDA ? function (it) { + return typeof it == 'object' ? it !== null : isCallable$j(it) || it === documentAll; + } : function (it) { + return typeof it == 'object' ? it !== null : isCallable$j(it); + }; + + var objectDefineProperty = {}; + + var global$g = global$k; + var isObject$h = isObject$i; + + var document$3 = global$g.document; + // typeof document.createElement is 'object' in old IE + var EXISTS = isObject$h(document$3) && isObject$h(document$3.createElement); + + var documentCreateElement$2 = function (it) { + return EXISTS ? document$3.createElement(it) : {}; + }; + + var DESCRIPTORS$c = descriptors; + var fails$m = fails$p; + var createElement$1 = documentCreateElement$2; + + // Thanks to IE8 for its funny defineProperty + var ie8DomDefine = !DESCRIPTORS$c && !fails$m(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { + get: function () { return 7; } + }).a !== 7; + }); + + var DESCRIPTORS$b = descriptors; + var fails$l = fails$p; + + // V8 ~ Chrome 36- + // https://bugs.chromium.org/p/v8/issues/detail?id=3334 + var v8PrototypeDefineBug = DESCRIPTORS$b && fails$l(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; + }); + + var isObject$g = isObject$i; + + var $String$5 = String; + var $TypeError$e = TypeError; + + // `Assert: Type(argument) is Object` + var anObject$c = function (argument) { + if (isObject$g(argument)) return argument; + throw new $TypeError$e($String$5(argument) + ' is not an object'); + }; + + var NATIVE_BIND$2 = functionBindNative; + + var call$f = Function.prototype.call; + + var functionCall = NATIVE_BIND$2 ? call$f.bind(call$f) : function () { + return call$f.apply(call$f, arguments); + }; + + var global$f = global$k; + var isCallable$i = isCallable$m; + + var aFunction = function (argument) { + return isCallable$i(argument) ? argument : undefined; + }; + + var getBuiltIn$7 = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$f[namespace]) : global$f[namespace] && global$f[namespace][method]; + }; + + var uncurryThis$n = functionUncurryThis; + + var objectIsPrototypeOf = uncurryThis$n({}.isPrototypeOf); + + var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || ''; + + var global$e = global$k; + var userAgent$5 = engineUserAgent; + + var process$3 = global$e.process; + var Deno$1 = global$e.Deno; + var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version; + var v8 = versions && versions.v8; + var match, version; + + if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); + } + + // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` + // so check `userAgent` even if `.v8` exists, but 0 + if (!version && userAgent$5) { + match = userAgent$5.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$5.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } + } + + var engineV8Version = version; + + /* eslint-disable es/no-symbol -- required for testing */ + var V8_VERSION$3 = engineV8Version; + var fails$k = fails$p; + var global$d = global$k; + + var $String$4 = global$d.String; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing + var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$k(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String$4(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$3 && V8_VERSION$3 < 41; + }); + + /* eslint-disable es/no-symbol -- required for testing */ + var NATIVE_SYMBOL$1 = symbolConstructorDetection; + + var useSymbolAsUid = NATIVE_SYMBOL$1 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + + var getBuiltIn$6 = getBuiltIn$7; + var isCallable$h = isCallable$m; + var isPrototypeOf$2 = objectIsPrototypeOf; + var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + + var $Object$3 = Object; + + var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) { + return typeof it == 'symbol'; + } : function (it) { + var $Symbol = getBuiltIn$6('Symbol'); + return isCallable$h($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it)); + }; + + var $String$3 = String; + + var tryToString$5 = function (argument) { + try { + return $String$3(argument); + } catch (error) { + return 'Object'; + } + }; + + var isCallable$g = isCallable$m; + var tryToString$4 = tryToString$5; + + var $TypeError$d = TypeError; + + // `Assert: IsCallable(argument) is true` + var aCallable$a = function (argument) { + if (isCallable$g(argument)) return argument; + throw new $TypeError$d(tryToString$4(argument) + ' is not a function'); + }; + + var aCallable$9 = aCallable$a; + var isNullOrUndefined$5 = isNullOrUndefined$7; + + // `GetMethod` abstract operation + // https://tc39.es/ecma262/#sec-getmethod + var getMethod$3 = function (V, P) { + var func = V[P]; + return isNullOrUndefined$5(func) ? undefined : aCallable$9(func); + }; + + var call$e = functionCall; + var isCallable$f = isCallable$m; + var isObject$f = isObject$i; + + var $TypeError$c = TypeError; + + // `OrdinaryToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-ordinarytoprimitive + var ordinaryToPrimitive$1 = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable$f(fn = input.toString) && !isObject$f(val = call$e(fn, input))) return val; + if (isCallable$f(fn = input.valueOf) && !isObject$f(val = call$e(fn, input))) return val; + if (pref !== 'string' && isCallable$f(fn = input.toString) && !isObject$f(val = call$e(fn, input))) return val; + throw new $TypeError$c("Can't convert object to primitive value"); + }; + + var shared$3 = {exports: {}}; + + var store$1 = sharedStore; + + (shared$3.exports = function (key, value) { + return store$1[key] || (store$1[key] = value !== undefined ? value : {}); + })('versions', []).push({ + version: '3.34.0', + mode: 'global', + copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE', + source: 'https://github.com/zloirock/core-js' + }); + + var sharedExports = shared$3.exports; + + var uncurryThis$m = functionUncurryThis; + + var id$2 = 0; + var postfix = Math.random(); + var toString$8 = uncurryThis$m(1.0.toString); + + var uid$3 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$8(++id$2 + postfix, 36); + }; + + var global$c = global$k; + var shared$2 = sharedExports; + var hasOwn$a = hasOwnProperty_1; + var uid$2 = uid$3; + var NATIVE_SYMBOL = symbolConstructorDetection; + var USE_SYMBOL_AS_UID = useSymbolAsUid; + + var Symbol$1 = global$c.Symbol; + var WellKnownSymbolsStore = shared$2('wks'); + var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$2; + + var wellKnownSymbol$k = function (name) { + if (!hasOwn$a(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$a(Symbol$1, name) + ? Symbol$1[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; + }; + + var call$d = functionCall; + var isObject$e = isObject$i; + var isSymbol$1 = isSymbol$2; + var getMethod$2 = getMethod$3; + var ordinaryToPrimitive = ordinaryToPrimitive$1; + var wellKnownSymbol$j = wellKnownSymbol$k; + + var $TypeError$b = TypeError; + var TO_PRIMITIVE = wellKnownSymbol$j('toPrimitive'); + + // `ToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-toprimitive + var toPrimitive$1 = function (input, pref) { + if (!isObject$e(input) || isSymbol$1(input)) return input; + var exoticToPrim = getMethod$2(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$d(exoticToPrim, input, pref); + if (!isObject$e(result) || isSymbol$1(result)) return result; + throw new $TypeError$b("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); + }; + + var toPrimitive = toPrimitive$1; + var isSymbol = isSymbol$2; + + // `ToPropertyKey` abstract operation + // https://tc39.es/ecma262/#sec-topropertykey + var toPropertyKey$3 = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; + }; + + var DESCRIPTORS$a = descriptors; + var IE8_DOM_DEFINE$1 = ie8DomDefine; + var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug; + var anObject$b = anObject$c; + var toPropertyKey$2 = toPropertyKey$3; + + var $TypeError$a = TypeError; + // eslint-disable-next-line es/no-object-defineproperty -- safe + var $defineProperty = Object.defineProperty; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; + var ENUMERABLE = 'enumerable'; + var CONFIGURABLE = 'configurable'; + var WRITABLE = 'writable'; + + // `Object.defineProperty` method + // https://tc39.es/ecma262/#sec-object.defineproperty + objectDefineProperty.f = DESCRIPTORS$a ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) { + anObject$b(O); + P = toPropertyKey$2(P); + anObject$b(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor$1(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); + } : $defineProperty : function defineProperty(O, P, Attributes) { + anObject$b(O); + P = toPropertyKey$2(P); + anObject$b(Attributes); + if (IE8_DOM_DEFINE$1) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$a('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; + }; + + var createPropertyDescriptor$4 = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; + }; + + var DESCRIPTORS$9 = descriptors; + var definePropertyModule$4 = objectDefineProperty; + var createPropertyDescriptor$3 = createPropertyDescriptor$4; + + var createNonEnumerableProperty$5 = DESCRIPTORS$9 ? function (object, key, value) { + return definePropertyModule$4.f(object, key, createPropertyDescriptor$3(1, value)); + } : function (object, key, value) { + object[key] = value; + return object; + }; + + var shared$1 = sharedExports; + var uid$1 = uid$3; + + var keys = shared$1('keys'); + + var sharedKey$3 = function (key) { + return keys[key] || (keys[key] = uid$1(key)); + }; + + var hiddenKeys$5 = {}; + + var NATIVE_WEAK_MAP = weakMapBasicDetection; + var global$b = global$k; + var isObject$d = isObject$i; + var createNonEnumerableProperty$4 = createNonEnumerableProperty$5; + var hasOwn$9 = hasOwnProperty_1; + var shared = sharedStore; + var sharedKey$2 = sharedKey$3; + var hiddenKeys$4 = hiddenKeys$5; + + var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; + var TypeError$2 = global$b.TypeError; + var WeakMap = global$b.WeakMap; + var set$1, get, has; + + var enforce = function (it) { + return has(it) ? get(it) : set$1(it, {}); + }; + + var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject$d(it) || (state = get(it)).type !== TYPE) { + throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; + }; + + if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set$1 = function (it, metadata) { + if (store.has(it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get = function (it) { + return store.get(it) || {}; + }; + has = function (it) { + return store.has(it); + }; + } else { + var STATE = sharedKey$2('state'); + hiddenKeys$4[STATE] = true; + set$1 = function (it, metadata) { + if (hasOwn$9(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty$4(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn$9(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn$9(it, STATE); + }; + } + + var internalState = { + set: set$1, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor + }; + + var uncurryThis$l = functionUncurryThis; + var fails$j = fails$p; + var isCallable$e = isCallable$m; + var hasOwn$8 = hasOwnProperty_1; + var DESCRIPTORS$8 = descriptors; + var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE; + var inspectSource$2 = inspectSource$3; + var InternalStateModule$5 = internalState; + + var enforceInternalState = InternalStateModule$5.enforce; + var getInternalState$2 = InternalStateModule$5.get; + var $String$2 = String; + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$6 = Object.defineProperty; + var stringSlice$3 = uncurryThis$l(''.slice); + var replace$1 = uncurryThis$l(''.replace); + var join = uncurryThis$l([].join); + + var CONFIGURABLE_LENGTH = DESCRIPTORS$8 && !fails$j(function () { + return defineProperty$6(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; + }); + + var TEMPLATE = String(String).split('String'); + + var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) { + if (stringSlice$3($String$2(name), 0, 7) === 'Symbol(') { + name = '[' + replace$1($String$2(name), /^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn$8(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) { + if (DESCRIPTORS$8) defineProperty$6(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn$8(options, 'arity') && value.length !== options.arity) { + defineProperty$6(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn$8(options, 'constructor') && options.constructor) { + if (DESCRIPTORS$8) defineProperty$6(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn$8(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; + }; + + // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative + // eslint-disable-next-line no-extend-native -- required + Function.prototype.toString = makeBuiltIn$2(function toString() { + return isCallable$e(this) && getInternalState$2(this).source || inspectSource$2(this); + }, 'toString'); + + var makeBuiltInExports = makeBuiltIn$3.exports; + + var makeBuiltIn$1 = makeBuiltInExports; + var defineProperty$5 = objectDefineProperty; + + var defineBuiltInAccessor$3 = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn$1(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn$1(descriptor.set, name, { setter: true }); + return defineProperty$5.f(target, name, descriptor); + }; + + var DESCRIPTORS$7 = descriptors; + var FUNCTION_NAME_EXISTS = functionName.EXISTS; + var uncurryThis$k = functionUncurryThis; + var defineBuiltInAccessor$2 = defineBuiltInAccessor$3; + + var FunctionPrototype$1 = Function.prototype; + var functionToString = uncurryThis$k(FunctionPrototype$1.toString); + var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; + var regExpExec = uncurryThis$k(nameRE.exec); + var NAME = 'name'; + + // Function instances `.name` property + // https://tc39.es/ecma262/#sec-function-instances-name + if (DESCRIPTORS$7 && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor$2(FunctionPrototype$1, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); + } + + var objectGetOwnPropertyDescriptor = {}; + + var objectPropertyIsEnumerable = {}; + + var $propertyIsEnumerable$1 = {}.propertyIsEnumerable; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getOwnPropertyDescriptor$3 = Object.getOwnPropertyDescriptor; + + // Nashorn ~ JDK8 bug + var NASHORN_BUG = getOwnPropertyDescriptor$3 && !$propertyIsEnumerable$1.call({ 1: 2 }, 1); + + // `Object.prototype.propertyIsEnumerable` method implementation + // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable + objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor$3(this, V); + return !!descriptor && descriptor.enumerable; + } : $propertyIsEnumerable$1; + + var uncurryThis$j = functionUncurryThis; + + var toString$7 = uncurryThis$j({}.toString); + var stringSlice$2 = uncurryThis$j(''.slice); + + var classofRaw$2 = function (it) { + return stringSlice$2(toString$7(it), 8, -1); + }; + + var uncurryThis$i = functionUncurryThis; + var fails$i = fails$p; + var classof$a = classofRaw$2; + + var $Object$2 = Object; + var split = uncurryThis$i(''.split); + + // fallback for non-array-like ES3 and non-enumerable old V8 strings + var indexedObject = fails$i(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object$2('z').propertyIsEnumerable(0); + }) ? function (it) { + return classof$a(it) === 'String' ? split(it, '') : $Object$2(it); + } : $Object$2; + + // toObject with fallback for non-array-like ES3 strings + var IndexedObject$3 = indexedObject; + var requireObjectCoercible$3 = requireObjectCoercible$5; + + var toIndexedObject$9 = function (it) { + return IndexedObject$3(requireObjectCoercible$3(it)); + }; + + var DESCRIPTORS$6 = descriptors; + var call$c = functionCall; + var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; + var createPropertyDescriptor$2 = createPropertyDescriptor$4; + var toIndexedObject$8 = toIndexedObject$9; + var toPropertyKey$1 = toPropertyKey$3; + var hasOwn$7 = hasOwnProperty_1; + var IE8_DOM_DEFINE = ie8DomDefine; + + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + + // `Object.getOwnPropertyDescriptor` method + // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor + objectGetOwnPropertyDescriptor.f = DESCRIPTORS$6 ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$8(O); + P = toPropertyKey$1(P); + if (IE8_DOM_DEFINE) try { + return $getOwnPropertyDescriptor(O, P); + } catch (error) { /* empty */ } + if (hasOwn$7(O, P)) return createPropertyDescriptor$2(!call$c(propertyIsEnumerableModule$1.f, O, P), O[P]); + }; + + var isCallable$d = isCallable$m; + var definePropertyModule$3 = objectDefineProperty; + var makeBuiltIn = makeBuiltInExports; + var defineGlobalProperty$1 = defineGlobalProperty$3; + + var defineBuiltIn$8 = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable$d(value)) makeBuiltIn(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty$1(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule$3.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; + }; + + var objectGetOwnPropertyNames = {}; + + var ceil = Math.ceil; + var floor$1 = Math.floor; + + // `Math.trunc` method + // https://tc39.es/ecma262/#sec-math.trunc + // eslint-disable-next-line es/no-math-trunc -- safe + var mathTrunc = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor$1 : ceil)(n); + }; + + var trunc = mathTrunc; + + // `ToIntegerOrInfinity` abstract operation + // https://tc39.es/ecma262/#sec-tointegerorinfinity + var toIntegerOrInfinity$3 = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); + }; + + var toIntegerOrInfinity$2 = toIntegerOrInfinity$3; + + var max$2 = Math.max; + var min$2 = Math.min; + + // Helper for a popular repeating case of the spec: + // Let integer be ? ToInteger(index). + // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). + var toAbsoluteIndex$3 = function (index, length) { + var integer = toIntegerOrInfinity$2(index); + return integer < 0 ? max$2(integer + length, 0) : min$2(integer, length); + }; + + var toIntegerOrInfinity$1 = toIntegerOrInfinity$3; + + var min$1 = Math.min; + + // `ToLength` abstract operation + // https://tc39.es/ecma262/#sec-tolength + var toLength$2 = function (argument) { + return argument > 0 ? min$1(toIntegerOrInfinity$1(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 + }; + + var toLength$1 = toLength$2; + + // `LengthOfArrayLike` abstract operation + // https://tc39.es/ecma262/#sec-lengthofarraylike + var lengthOfArrayLike$8 = function (obj) { + return toLength$1(obj.length); + }; + + var toIndexedObject$7 = toIndexedObject$9; + var toAbsoluteIndex$2 = toAbsoluteIndex$3; + var lengthOfArrayLike$7 = lengthOfArrayLike$8; + + // `Array.prototype.{ indexOf, includes }` methods implementation + var createMethod$4 = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject$7($this); + var length = lengthOfArrayLike$7(O); + var index = toAbsoluteIndex$2(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; + }; + + var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod$4(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod$4(false) + }; + + var uncurryThis$h = functionUncurryThis; + var hasOwn$6 = hasOwnProperty_1; + var toIndexedObject$6 = toIndexedObject$9; + var indexOf = arrayIncludes.indexOf; + var hiddenKeys$3 = hiddenKeys$5; + + var push$3 = uncurryThis$h([].push); + + var objectKeysInternal = function (object, names) { + var O = toIndexedObject$6(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn$6(hiddenKeys$3, key) && hasOwn$6(O, key) && push$3(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn$6(O, key = names[i++])) { + ~indexOf(result, key) || push$3(result, key); + } + return result; + }; + + // IE8- don't enum bug keys + var enumBugKeys$3 = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' + ]; + + var internalObjectKeys$1 = objectKeysInternal; + var enumBugKeys$2 = enumBugKeys$3; + + var hiddenKeys$2 = enumBugKeys$2.concat('length', 'prototype'); + + // `Object.getOwnPropertyNames` method + // https://tc39.es/ecma262/#sec-object.getownpropertynames + // eslint-disable-next-line es/no-object-getownpropertynames -- safe + objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys$2); + }; + + var objectGetOwnPropertySymbols = {}; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe + objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; + + var getBuiltIn$5 = getBuiltIn$7; + var uncurryThis$g = functionUncurryThis; + var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames; + var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; + var anObject$a = anObject$c; + + var concat$1 = uncurryThis$g([].concat); + + // all object keys, includes non-enumerable and symbols + var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule$1.f(anObject$a(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f; + return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys; + }; + + var hasOwn$5 = hasOwnProperty_1; + var ownKeys = ownKeys$1; + var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; + var definePropertyModule$2 = objectDefineProperty; + + var copyConstructorProperties$1 = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule$2.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn$5(target, key) && !(exceptions && hasOwn$5(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } + }; + + var fails$h = fails$p; + var isCallable$c = isCallable$m; + + var replacement = /#|\.prototype\./; + + var isForced$3 = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable$c(detection) ? fails$h(detection) + : !!detection; + }; + + var normalize = isForced$3.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); + }; + + var data = isForced$3.data = {}; + var NATIVE = isForced$3.NATIVE = 'N'; + var POLYFILL = isForced$3.POLYFILL = 'P'; + + var isForced_1 = isForced$3; + + var global$a = global$k; + var getOwnPropertyDescriptor$2 = objectGetOwnPropertyDescriptor.f; + var createNonEnumerableProperty$3 = createNonEnumerableProperty$5; + var defineBuiltIn$7 = defineBuiltIn$8; + var defineGlobalProperty = defineGlobalProperty$3; + var copyConstructorProperties = copyConstructorProperties$1; + var isForced$2 = isForced_1; + + /* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key + */ + var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global$a; + } else if (STATIC) { + target = global$a[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = (global$a[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor$2(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced$2(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty$3(sourceProperty, 'sham', true); + } + defineBuiltIn$7(target, key, sourceProperty, options); + } + }; + + var internalObjectKeys = objectKeysInternal; + var enumBugKeys$1 = enumBugKeys$3; + + // `Object.keys` method + // https://tc39.es/ecma262/#sec-object.keys + // eslint-disable-next-line es/no-object-keys -- safe + var objectKeys$3 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys$1); + }; + + var DESCRIPTORS$5 = descriptors; + var uncurryThis$f = functionUncurryThis; + var call$b = functionCall; + var fails$g = fails$p; + var objectKeys$2 = objectKeys$3; + var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; + var propertyIsEnumerableModule = objectPropertyIsEnumerable; + var toObject$6 = toObject$8; + var IndexedObject$2 = indexedObject; + + // eslint-disable-next-line es/no-object-assign -- safe + var $assign = Object.assign; + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + var defineProperty$4 = Object.defineProperty; + var concat = uncurryThis$f([].concat); + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + var objectAssign = !$assign || fails$g(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$5 && $assign({ b: 1 }, $assign(defineProperty$4({}, 'a', { + enumerable: true, + get: function () { + defineProperty$4(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys$2($assign({}, B)).join('') !== alphabet; + }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject$6(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject$2(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys$2(S), getOwnPropertySymbols(S)) : objectKeys$2(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$5 || call$b(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; + } : $assign; + + var $$m = _export; + var assign = objectAssign; + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + // eslint-disable-next-line es/no-object-assign -- required for testing + $$m({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign + }); + + var wellKnownSymbol$i = wellKnownSymbol$k; + + var TO_STRING_TAG$2 = wellKnownSymbol$i('toStringTag'); + var test$1 = {}; + + test$1[TO_STRING_TAG$2] = 'z'; + + var toStringTagSupport = String(test$1) === '[object z]'; + + var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; + var isCallable$b = isCallable$m; + var classofRaw$1 = classofRaw$2; + var wellKnownSymbol$h = wellKnownSymbol$k; + + var TO_STRING_TAG$1 = wellKnownSymbol$h('toStringTag'); + var $Object$1 = Object; + + // ES3 wrong here + var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments'; + + // fallback for IE11 Script Access Denied error + var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } + }; + + // getting tag from ES6+ `Object.prototype.toString` + var classof$9 = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object$1(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw$1(O) + // ES3 arguments fallback + : (result = classofRaw$1(O)) === 'Object' && isCallable$b(O.callee) ? 'Arguments' : result; + }; + + var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; + var classof$8 = classof$9; + + // `Object.prototype.toString` method implementation + // https://tc39.es/ecma262/#sec-object.prototype.tostring + var objectToString$1 = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$8(this) + ']'; + }; + + var TO_STRING_TAG_SUPPORT = toStringTagSupport; + var defineBuiltIn$6 = defineBuiltIn$8; + var toString$6 = objectToString$1; + + // `Object.prototype.toString` method + // https://tc39.es/ecma262/#sec-object.prototype.tostring + if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn$6(Object.prototype, 'toString', toString$6, { unsafe: true }); + } + + var global$9 = global$k; + var classof$7 = classofRaw$2; + + var engineIsNode = classof$7(global$9.process) === 'process'; + + var uncurryThis$e = functionUncurryThis; + var aCallable$8 = aCallable$a; + + var functionUncurryThisAccessor = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis$e(aCallable$8(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } + }; + + var isCallable$a = isCallable$m; + + var $String$1 = String; + var $TypeError$9 = TypeError; + + var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$a(argument)) return argument; + throw new $TypeError$9("Can't set " + $String$1(argument) + ' as a prototype'); + }; + + /* eslint-disable no-proto -- safe */ + var uncurryThisAccessor = functionUncurryThisAccessor; + var anObject$9 = anObject$c; + var aPossiblePrototype = aPossiblePrototype$1; + + // `Object.setPrototypeOf` method + // https://tc39.es/ecma262/#sec-object.setprototypeof + // Works with __proto__ only. Old v8 can't work with null proto objects. + // eslint-disable-next-line es/no-object-setprototypeof -- safe + var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject$9(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; + }() : undefined); + + var defineProperty$3 = objectDefineProperty.f; + var hasOwn$4 = hasOwnProperty_1; + var wellKnownSymbol$g = wellKnownSymbol$k; + + var TO_STRING_TAG = wellKnownSymbol$g('toStringTag'); + + var setToStringTag$5 = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$4(target, TO_STRING_TAG)) { + defineProperty$3(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } + }; + + var getBuiltIn$4 = getBuiltIn$7; + var defineBuiltInAccessor$1 = defineBuiltInAccessor$3; + var wellKnownSymbol$f = wellKnownSymbol$k; + var DESCRIPTORS$4 = descriptors; + + var SPECIES$5 = wellKnownSymbol$f('species'); + + var setSpecies$2 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$4(CONSTRUCTOR_NAME); + + if (DESCRIPTORS$4 && Constructor && !Constructor[SPECIES$5]) { + defineBuiltInAccessor$1(Constructor, SPECIES$5, { + configurable: true, + get: function () { return this; } + }); + } + }; + + var isPrototypeOf$1 = objectIsPrototypeOf; + + var $TypeError$8 = TypeError; + + var anInstance$4 = function (it, Prototype) { + if (isPrototypeOf$1(Prototype, it)) return it; + throw new $TypeError$8('Incorrect invocation'); + }; + + var uncurryThis$d = functionUncurryThis; + var fails$f = fails$p; + var isCallable$9 = isCallable$m; + var classof$6 = classof$9; + var getBuiltIn$3 = getBuiltIn$7; + var inspectSource$1 = inspectSource$3; + + var noop = function () { /* empty */ }; + var empty = []; + var construct = getBuiltIn$3('Reflect', 'construct'); + var constructorRegExp = /^\s*(?:class|function)\b/; + var exec = uncurryThis$d(constructorRegExp.exec); + var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + + var isConstructorModern = function isConstructor(argument) { + if (!isCallable$9(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } + }; + + var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$9(argument)) return false; + switch (classof$6(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } + }; + + isConstructorLegacy.sham = true; + + // `IsConstructor` abstract operation + // https://tc39.es/ecma262/#sec-isconstructor + var isConstructor$4 = !construct || fails$f(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; + }) ? isConstructorLegacy : isConstructorModern; + + var isConstructor$3 = isConstructor$4; + var tryToString$3 = tryToString$5; + + var $TypeError$7 = TypeError; + + // `Assert: IsConstructor(argument) is true` + var aConstructor$1 = function (argument) { + if (isConstructor$3(argument)) return argument; + throw new $TypeError$7(tryToString$3(argument) + ' is not a constructor'); + }; + + var anObject$8 = anObject$c; + var aConstructor = aConstructor$1; + var isNullOrUndefined$4 = isNullOrUndefined$7; + var wellKnownSymbol$e = wellKnownSymbol$k; + + var SPECIES$4 = wellKnownSymbol$e('species'); + + // `SpeciesConstructor` abstract operation + // https://tc39.es/ecma262/#sec-speciesconstructor + var speciesConstructor$1 = function (O, defaultConstructor) { + var C = anObject$8(O).constructor; + var S; + return C === undefined || isNullOrUndefined$4(S = anObject$8(C)[SPECIES$4]) ? defaultConstructor : aConstructor(S); + }; + + var NATIVE_BIND$1 = functionBindNative; + + var FunctionPrototype = Function.prototype; + var apply$1 = FunctionPrototype.apply; + var call$a = FunctionPrototype.call; + + // eslint-disable-next-line es/no-reflect -- safe + var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$a.bind(apply$1) : function () { + return call$a.apply(apply$1, arguments); + }); + + var classofRaw = classofRaw$2; + var uncurryThis$c = functionUncurryThis; + + var functionUncurryThisClause = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis$c(fn); + }; + + var uncurryThis$b = functionUncurryThisClause; + var aCallable$7 = aCallable$a; + var NATIVE_BIND = functionBindNative; + + var bind$7 = uncurryThis$b(uncurryThis$b.bind); + + // optional / simple context binding + var functionBindContext = function (fn, that) { + aCallable$7(fn); + return that === undefined ? fn : NATIVE_BIND ? bind$7(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; + }; + + var getBuiltIn$2 = getBuiltIn$7; + + var html$2 = getBuiltIn$2('document', 'documentElement'); + + var uncurryThis$a = functionUncurryThis; + + var arraySlice$3 = uncurryThis$a([].slice); + + var $TypeError$6 = TypeError; + + var validateArgumentsLength$1 = function (passed, required) { + if (passed < required) throw new $TypeError$6('Not enough arguments'); + return passed; + }; + + var userAgent$4 = engineUserAgent; + + // eslint-disable-next-line redos/no-vulnerable -- safe + var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$4); + + var global$8 = global$k; + var apply = functionApply; + var bind$6 = functionBindContext; + var isCallable$8 = isCallable$m; + var hasOwn$3 = hasOwnProperty_1; + var fails$e = fails$p; + var html$1 = html$2; + var arraySlice$2 = arraySlice$3; + var createElement = documentCreateElement$2; + var validateArgumentsLength = validateArgumentsLength$1; + var IS_IOS$1 = engineIsIos; + var IS_NODE$3 = engineIsNode; + + var set = global$8.setImmediate; + var clear = global$8.clearImmediate; + var process$2 = global$8.process; + var Dispatch = global$8.Dispatch; + var Function$1 = global$8.Function; + var MessageChannel = global$8.MessageChannel; + var String$1 = global$8.String; + var counter = 0; + var queue$2 = {}; + var ONREADYSTATECHANGE = 'onreadystatechange'; + var $location, defer, channel, port; + + fails$e(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = global$8.location; + }); + + var run = function (id) { + if (hasOwn$3(queue$2, id)) { + var fn = queue$2[id]; + delete queue$2[id]; + fn(); + } + }; + + var runner = function (id) { + return function () { + run(id); + }; + }; + + var eventListener = function (event) { + run(event.data); + }; + + var globalPostMessageDefer = function (id) { + // old engines have not location.origin + global$8.postMessage(String$1(id), $location.protocol + '//' + $location.host); + }; + + // Node.js 0.9+ & IE10+ has setImmediate, otherwise: + if (!set || !clear) { + set = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable$8(handler) ? handler : Function$1(handler); + var args = arraySlice$2(arguments, 1); + queue$2[++counter] = function () { + apply(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue$2[id]; + }; + // Node.js 0.8- + if (IS_NODE$3) { + defer = function (id) { + process$2.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS$1) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind$6(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global$8.addEventListener && + isCallable$8(global$8.postMessage) && + !global$8.importScripts && + $location && $location.protocol !== 'file:' && + !fails$e(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + global$8.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html$1.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } + } + + var task$1 = { + set: set, + clear: clear + }; + + var Queue$2 = function () { + this.head = null; + this.tail = null; + }; + + Queue$2.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } + }; + + var queue$1 = Queue$2; + + var userAgent$3 = engineUserAgent; + + var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$3) && typeof Pebble != 'undefined'; + + var userAgent$2 = engineUserAgent; + + var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent$2); + + var global$7 = global$k; + var bind$5 = functionBindContext; + var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; + var macrotask = task$1.set; + var Queue$1 = queue$1; + var IS_IOS = engineIsIos; + var IS_IOS_PEBBLE = engineIsIosPebble; + var IS_WEBOS_WEBKIT = engineIsWebosWebkit; + var IS_NODE$2 = engineIsNode; + + var MutationObserver = global$7.MutationObserver || global$7.WebKitMutationObserver; + var document$2 = global$7.document; + var process$1 = global$7.process; + var Promise$1 = global$7.Promise; + // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` + var queueMicrotaskDescriptor = getOwnPropertyDescriptor$1(global$7, 'queueMicrotask'); + var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; + var notify$1, toggle, node, promise, then; + + // modern engines have queueMicrotask method + if (!microtask$1) { + var queue = new Queue$1(); + + var flush = function () { + var parent, fn; + if (IS_NODE$2 && (parent = process$1.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify$1(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { + toggle = true; + node = document$2.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify$1 = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise$1.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise$1; + then = bind$5(promise.then, promise); + notify$1 = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE$2) { + notify$1 = function () { + process$1.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind$5(macrotask, global$7); + notify$1 = function () { + macrotask(flush); + }; + } + + microtask$1 = function (fn) { + if (!queue.head) notify$1(); + queue.add(fn); + }; + } + + var microtask_1 = microtask$1; + + var hostReportErrors$1 = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } + }; + + var perform$4 = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } + }; + + var global$6 = global$k; + + var promiseNativeConstructor = global$6.Promise; + + /* global Deno -- Deno case */ + var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object'; + + var IS_DENO$1 = engineIsDeno; + var IS_NODE$1 = engineIsNode; + + var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 + && typeof window == 'object' + && typeof document == 'object'; + + var global$5 = global$k; + var NativePromiseConstructor$3 = promiseNativeConstructor; + var isCallable$7 = isCallable$m; + var isForced$1 = isForced_1; + var inspectSource = inspectSource$3; + var wellKnownSymbol$d = wellKnownSymbol$k; + var IS_BROWSER = engineIsBrowser; + var IS_DENO = engineIsDeno; + var V8_VERSION$2 = engineV8Version; + + NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype; + var SPECIES$3 = wellKnownSymbol$d('species'); + var SUBCLASSING = false; + var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$7(global$5.PromiseRejectionEvent); + + var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION$2 === 66) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION$2 || V8_VERSION$2 < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES$3] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1; + }); + + var promiseConstructorDetection = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1, + SUBCLASSING: SUBCLASSING + }; + + var newPromiseCapability$2 = {}; + + var aCallable$6 = aCallable$a; + + var $TypeError$5 = TypeError; + + var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError$5('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable$6(resolve); + this.reject = aCallable$6(reject); + }; + + // `NewPromiseCapability` abstract operation + // https://tc39.es/ecma262/#sec-newpromisecapability + newPromiseCapability$2.f = function (C) { + return new PromiseCapability(C); + }; + + var $$l = _export; + var IS_NODE = engineIsNode; + var global$4 = global$k; + var call$9 = functionCall; + var defineBuiltIn$5 = defineBuiltIn$8; + var setPrototypeOf$2 = objectSetPrototypeOf; + var setToStringTag$4 = setToStringTag$5; + var setSpecies$1 = setSpecies$2; + var aCallable$5 = aCallable$a; + var isCallable$6 = isCallable$m; + var isObject$c = isObject$i; + var anInstance$3 = anInstance$4; + var speciesConstructor = speciesConstructor$1; + var task = task$1.set; + var microtask = microtask_1; + var hostReportErrors = hostReportErrors$1; + var perform$3 = perform$4; + var Queue = queue$1; + var InternalStateModule$4 = internalState; + var NativePromiseConstructor$2 = promiseNativeConstructor; + var PromiseConstructorDetection = promiseConstructorDetection; + var newPromiseCapabilityModule$4 = newPromiseCapability$2; + + var PROMISE = 'Promise'; + var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR; + var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; + var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; + var getInternalPromiseState = InternalStateModule$4.getterFor(PROMISE); + var setInternalState$4 = InternalStateModule$4.set; + var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype; + var PromiseConstructor = NativePromiseConstructor$2; + var PromisePrototype = NativePromisePrototype$1; + var TypeError$1 = global$4.TypeError; + var document$1 = global$4.document; + var process = global$4.process; + var newPromiseCapability$1 = newPromiseCapabilityModule$4.f; + var newGenericPromiseCapability = newPromiseCapability$1; + + var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$4.dispatchEvent); + var UNHANDLED_REJECTION = 'unhandledrejection'; + var REJECTION_HANDLED = 'rejectionhandled'; + var PENDING = 0; + var FULFILLED = 1; + var REJECTED = 2; + var HANDLED = 1; + var UNHANDLED = 2; + + var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + + // helpers + var isThenable = function (it) { + var then; + return isObject$c(it) && isCallable$6(then = it.then) ? then : false; + }; + + var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$9(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } + }; + + var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); + }; + + var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$1.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global$4.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$4['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); + }; + + var onUnhandled = function (state) { + call$9(task, global$4, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform$3(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); + }; + + var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; + }; + + var onHandleUnhandled = function (state) { + call$9(task, global$4, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); + }; + + var bind$4 = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; + }; + + var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); + }; + + var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call$9(then, value, + bind$4(internalResolve, wrapper, state), + bind$4(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } + }; + + // constructor polyfill + if (FORCED_PROMISE_CONSTRUCTOR$4) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance$3(this, PromisePrototype); + aCallable$5(executor); + call$9(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind$4(internalResolve, state), bind$4(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState$4(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: undefined + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn$5(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable$6(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$6(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind$4(internalResolve, state); + this.reject = bind$4(internalReject, state); + }; + + newPromiseCapabilityModule$4.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (isCallable$6(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) { + nativeThen = NativePromisePrototype$1.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn$5(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call$9(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype$1.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf$2) { + setPrototypeOf$2(NativePromisePrototype$1, PromisePrototype); + } + } + } + + $$l({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, { + Promise: PromiseConstructor + }); + + setToStringTag$4(PromiseConstructor, PROMISE, false); + setSpecies$1(PROMISE); + + var iterators = {}; + + var wellKnownSymbol$c = wellKnownSymbol$k; + var Iterators$4 = iterators; + + var ITERATOR$5 = wellKnownSymbol$c('iterator'); + var ArrayPrototype$1 = Array.prototype; + + // check on default Array iterator + var isArrayIteratorMethod$2 = function (it) { + return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$5] === it); + }; + + var classof$5 = classof$9; + var getMethod$1 = getMethod$3; + var isNullOrUndefined$3 = isNullOrUndefined$7; + var Iterators$3 = iterators; + var wellKnownSymbol$b = wellKnownSymbol$k; + + var ITERATOR$4 = wellKnownSymbol$b('iterator'); + + var getIteratorMethod$3 = function (it) { + if (!isNullOrUndefined$3(it)) return getMethod$1(it, ITERATOR$4) + || getMethod$1(it, '@@iterator') + || Iterators$3[classof$5(it)]; + }; + + var call$8 = functionCall; + var aCallable$4 = aCallable$a; + var anObject$7 = anObject$c; + var tryToString$2 = tryToString$5; + var getIteratorMethod$2 = getIteratorMethod$3; + + var $TypeError$4 = TypeError; + + var getIterator$2 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$2(argument) : usingIterator; + if (aCallable$4(iteratorMethod)) return anObject$7(call$8(iteratorMethod, argument)); + throw new $TypeError$4(tryToString$2(argument) + ' is not iterable'); + }; + + var call$7 = functionCall; + var anObject$6 = anObject$c; + var getMethod = getMethod$3; + + var iteratorClose$2 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$6(iterator); + try { + innerResult = getMethod(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$7(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$6(innerResult); + return value; + }; + + var bind$3 = functionBindContext; + var call$6 = functionCall; + var anObject$5 = anObject$c; + var tryToString$1 = tryToString$5; + var isArrayIteratorMethod$1 = isArrayIteratorMethod$2; + var lengthOfArrayLike$6 = lengthOfArrayLike$8; + var isPrototypeOf = objectIsPrototypeOf; + var getIterator$1 = getIterator$2; + var getIteratorMethod$1 = getIteratorMethod$3; + var iteratorClose$1 = iteratorClose$2; + + var $TypeError$3 = TypeError; + + var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; + }; + + var ResultPrototype = Result.prototype; + + var iterate$6 = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind$3(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose$1(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject$5(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod$1(iterable); + if (!iterFn) throw new $TypeError$3(tryToString$1(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod$1(iterFn)) { + for (index = 0, length = lengthOfArrayLike$6(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator$1(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call$6(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose$1(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + }; + + var wellKnownSymbol$a = wellKnownSymbol$k; + + var ITERATOR$3 = wellKnownSymbol$a('iterator'); + var SAFE_CLOSING = false; + + try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR$3] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); + } catch (error) { /* empty */ } + + var checkCorrectnessOfIteration$3 = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR$3] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; + }; + + var NativePromiseConstructor$1 = promiseNativeConstructor; + var checkCorrectnessOfIteration$2 = checkCorrectnessOfIteration$3; + var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR; + + var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration$2(function (iterable) { + NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ }); + }); + + var $$k = _export; + var call$5 = functionCall; + var aCallable$3 = aCallable$a; + var newPromiseCapabilityModule$3 = newPromiseCapability$2; + var perform$2 = perform$4; + var iterate$5 = iterate$6; + var PROMISE_STATICS_INCORRECT_ITERATION$2 = promiseStaticsIncorrectIteration; + + // `Promise.all` method + // https://tc39.es/ecma262/#sec-promise.all + $$k({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$2 }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$3.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform$2(function () { + var $promiseResolve = aCallable$3(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$5(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$5($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var $$j = _export; + var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR; + var NativePromiseConstructor = promiseNativeConstructor; + var getBuiltIn$1 = getBuiltIn$7; + var isCallable$5 = isCallable$m; + var defineBuiltIn$4 = defineBuiltIn$8; + + var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + + // `Promise.prototype.catch` method + // https://tc39.es/ecma262/#sec-promise.prototype.catch + $$j({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + + // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` + if (isCallable$5(NativePromiseConstructor)) { + var method = getBuiltIn$1('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn$4(NativePromisePrototype, 'catch', method, { unsafe: true }); + } + } + + var $$i = _export; + var call$4 = functionCall; + var aCallable$2 = aCallable$a; + var newPromiseCapabilityModule$2 = newPromiseCapability$2; + var perform$1 = perform$4; + var iterate$4 = iterate$6; + var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration; + + // `Promise.race` method + // https://tc39.es/ecma262/#sec-promise.race + $$i({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$2.f(C); + var reject = capability.reject; + var result = perform$1(function () { + var $promiseResolve = aCallable$2(C.resolve); + iterate$4(iterable, function (promise) { + call$4($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var $$h = _export; + var call$3 = functionCall; + var newPromiseCapabilityModule$1 = newPromiseCapability$2; + var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR; + + // `Promise.reject` method + // https://tc39.es/ecma262/#sec-promise.reject + $$h({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule$1.f(this); + call$3(capability.reject, undefined, r); + return capability.promise; + } + }); + + var anObject$4 = anObject$c; + var isObject$b = isObject$i; + var newPromiseCapability = newPromiseCapability$2; + + var promiseResolve$1 = function (C, x) { + anObject$4(C); + if (isObject$b(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; + }; + + var $$g = _export; + var getBuiltIn = getBuiltIn$7; + var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR; + var promiseResolve = promiseResolve$1; + + getBuiltIn('Promise'); + + // `Promise.resolve` method + // https://tc39.es/ecma262/#sec-promise.resolve + $$g({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(this, x); + } + }); + + var objectDefineProperties = {}; + + var DESCRIPTORS$3 = descriptors; + var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; + var definePropertyModule$1 = objectDefineProperty; + var anObject$3 = anObject$c; + var toIndexedObject$5 = toIndexedObject$9; + var objectKeys$1 = objectKeys$3; + + // `Object.defineProperties` method + // https://tc39.es/ecma262/#sec-object.defineproperties + // eslint-disable-next-line es/no-object-defineproperties -- safe + objectDefineProperties.f = DESCRIPTORS$3 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject$3(O); + var props = toIndexedObject$5(Properties); + var keys = objectKeys$1(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule$1.f(O, key = keys[index++], props[key]); + return O; + }; + + /* global ActiveXObject -- old IE, WSH */ + var anObject$2 = anObject$c; + var definePropertiesModule = objectDefineProperties; + var enumBugKeys = enumBugKeys$3; + var hiddenKeys$1 = hiddenKeys$5; + var html = html$2; + var documentCreateElement$1 = documentCreateElement$2; + var sharedKey$1 = sharedKey$3; + + var GT = '>'; + var LT = '<'; + var PROTOTYPE = 'prototype'; + var SCRIPT = 'script'; + var IE_PROTO$1 = sharedKey$1('IE_PROTO'); + + var EmptyConstructor = function () { /* empty */ }; + + var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; + }; + + // Create object with fake `null` prototype: use ActiveX Object with cleared prototype + var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; + }; + + // Create object with fake `null` prototype: use iframe Object with cleared prototype + var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement$1('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; + }; + + // Check for document.domain and active x support + // No need to use active x approach when document.domain is not set + // see https://github.com/es-shims/es5-shim/issues/150 + // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 + // avoid IE GC bug + var activeXDocument; + var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); + }; + + hiddenKeys$1[IE_PROTO$1] = true; + + // `Object.create` method + // https://tc39.es/ecma262/#sec-object.create + // eslint-disable-next-line es/no-object-create -- safe + var objectCreate = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject$2(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO$1] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : definePropertiesModule.f(result, Properties); + }; + + var wellKnownSymbol$9 = wellKnownSymbol$k; + var create$2 = objectCreate; + var defineProperty$2 = objectDefineProperty.f; + + var UNSCOPABLES = wellKnownSymbol$9('unscopables'); + var ArrayPrototype = Array.prototype; + + // Array.prototype[@@unscopables] + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + if (ArrayPrototype[UNSCOPABLES] === undefined) { + defineProperty$2(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create$2(null) + }); + } + + // add a key to Array.prototype[@@unscopables] + var addToUnscopables$2 = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; + }; + + var fails$d = fails$p; + + var correctPrototypeGetter = !fails$d(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; + }); + + var hasOwn$2 = hasOwnProperty_1; + var isCallable$4 = isCallable$m; + var toObject$5 = toObject$8; + var sharedKey = sharedKey$3; + var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter; + + var IE_PROTO = sharedKey('IE_PROTO'); + var $Object = Object; + var ObjectPrototype = $Object.prototype; + + // `Object.getPrototypeOf` method + // https://tc39.es/ecma262/#sec-object.getprototypeof + // eslint-disable-next-line es/no-object-getprototypeof -- safe + var objectGetPrototypeOf$1 = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) { + var object = toObject$5(O); + if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable$4(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof $Object ? ObjectPrototype : null; + }; + + var fails$c = fails$p; + var isCallable$3 = isCallable$m; + var isObject$a = isObject$i; + var getPrototypeOf$1 = objectGetPrototypeOf$1; + var defineBuiltIn$3 = defineBuiltIn$8; + var wellKnownSymbol$8 = wellKnownSymbol$k; + + var ITERATOR$2 = wellKnownSymbol$8('iterator'); + var BUGGY_SAFARI_ITERATORS$1 = false; + + // `%IteratorPrototype%` object + // https://tc39.es/ecma262/#sec-%iteratorprototype%-object + var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator; + + /* eslint-disable es/no-array-prototype-keys -- safe */ + if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype; + } + } + + var NEW_ITERATOR_PROTOTYPE = !isObject$a(IteratorPrototype$2) || fails$c(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype$2[ITERATOR$2].call(test) !== test; + }); + + if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {}; + + // `%IteratorPrototype%[@@iterator]()` method + // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator + if (!isCallable$3(IteratorPrototype$2[ITERATOR$2])) { + defineBuiltIn$3(IteratorPrototype$2, ITERATOR$2, function () { + return this; + }); + } + + var iteratorsCore = { + IteratorPrototype: IteratorPrototype$2, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1 + }; + + var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; + var create$1 = objectCreate; + var createPropertyDescriptor$1 = createPropertyDescriptor$4; + var setToStringTag$3 = setToStringTag$5; + var Iterators$2 = iterators; + + var returnThis$1 = function () { return this; }; + + var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create$1(IteratorPrototype$1, { next: createPropertyDescriptor$1(+!ENUMERABLE_NEXT, next) }); + setToStringTag$3(IteratorConstructor, TO_STRING_TAG, false); + Iterators$2[TO_STRING_TAG] = returnThis$1; + return IteratorConstructor; + }; + + var $$f = _export; + var call$2 = functionCall; + var FunctionName = functionName; + var isCallable$2 = isCallable$m; + var createIteratorConstructor = iteratorCreateConstructor; + var getPrototypeOf = objectGetPrototypeOf$1; + var setPrototypeOf$1 = objectSetPrototypeOf; + var setToStringTag$2 = setToStringTag$5; + var createNonEnumerableProperty$2 = createNonEnumerableProperty$5; + var defineBuiltIn$2 = defineBuiltIn$8; + var wellKnownSymbol$7 = wellKnownSymbol$k; + var Iterators$1 = iterators; + var IteratorsCore = iteratorsCore; + + var PROPER_FUNCTION_NAME$1 = FunctionName.PROPER; + var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; + var IteratorPrototype = IteratorsCore.IteratorPrototype; + var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; + var ITERATOR$1 = wellKnownSymbol$7('iterator'); + var KEYS = 'keys'; + var VALUES = 'values'; + var ENTRIES = 'entries'; + + var returnThis = function () { return this; }; + + var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND]; + + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } + + return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR$1] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf$1) { + setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$1])) { + defineBuiltIn$2(CurrentIteratorPrototype, ITERATOR$1, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag$2(CurrentIteratorPrototype, TO_STRING_TAG, true); + } + } + + // fix Array.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME$1 && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty$2(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call$2(nativeIterator, this); }; + } + } + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + defineBuiltIn$2(IterablePrototype, KEY, methods[KEY]); + } + } else $$f({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if (IterablePrototype[ITERATOR$1] !== defaultIterator) { + defineBuiltIn$2(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT }); + } + Iterators$1[NAME] = defaultIterator; + + return methods; + }; + + // `CreateIterResultObject` abstract operation + // https://tc39.es/ecma262/#sec-createiterresultobject + var createIterResultObject$3 = function (value, done) { + return { value: value, done: done }; + }; + + var toIndexedObject$4 = toIndexedObject$9; + var addToUnscopables$1 = addToUnscopables$2; + var Iterators = iterators; + var InternalStateModule$3 = internalState; + var defineProperty$1 = objectDefineProperty.f; + var defineIterator$2 = iteratorDefine; + var createIterResultObject$2 = createIterResultObject$3; + var DESCRIPTORS$2 = descriptors; + + var ARRAY_ITERATOR = 'Array Iterator'; + var setInternalState$3 = InternalStateModule$3.set; + var getInternalState$1 = InternalStateModule$3.getterFor(ARRAY_ITERATOR); + + // `Array.prototype.entries` method + // https://tc39.es/ecma262/#sec-array.prototype.entries + // `Array.prototype.keys` method + // https://tc39.es/ecma262/#sec-array.prototype.keys + // `Array.prototype.values` method + // https://tc39.es/ecma262/#sec-array.prototype.values + // `Array.prototype[@@iterator]` method + // https://tc39.es/ecma262/#sec-array.prototype-@@iterator + // `CreateArrayIterator` internal method + // https://tc39.es/ecma262/#sec-createarrayiterator + var es_array_iterator = defineIterator$2(Array, 'Array', function (iterated, kind) { + setInternalState$3(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject$4(iterated), // target + index: 0, // next index + kind: kind // kind + }); + // `%ArrayIteratorPrototype%.next` method + // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next + }, function () { + var state = getInternalState$1(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return createIterResultObject$2(undefined, true); + } + switch (state.kind) { + case 'keys': return createIterResultObject$2(index, false); + case 'values': return createIterResultObject$2(target[index], false); + } return createIterResultObject$2([index, target[index]], false); + }, 'values'); + + // argumentsList[@@iterator] is %ArrayProto_values% + // https://tc39.es/ecma262/#sec-createunmappedargumentsobject + // https://tc39.es/ecma262/#sec-createmappedargumentsobject + var values = Iterators.Arguments = Iterators.Array; + + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + addToUnscopables$1('keys'); + addToUnscopables$1('values'); + addToUnscopables$1('entries'); + + // V8 ~ Chrome 45- bug + if (DESCRIPTORS$2 && values.name !== 'values') try { + defineProperty$1(values, 'name', { value: 'values' }); + } catch (error) { /* empty */ } + + var classof$4 = classof$9; + + var $String = String; + + var toString$5 = function (argument) { + if (classof$4(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string'); + return $String(argument); + }; + + var uncurryThis$9 = functionUncurryThis; + var toIntegerOrInfinity = toIntegerOrInfinity$3; + var toString$4 = toString$5; + var requireObjectCoercible$2 = requireObjectCoercible$5; + + var charAt$1 = uncurryThis$9(''.charAt); + var charCodeAt = uncurryThis$9(''.charCodeAt); + var stringSlice$1 = uncurryThis$9(''.slice); + + var createMethod$3 = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = toString$4(requireObjectCoercible$2($this)); + var position = toIntegerOrInfinity(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = charCodeAt(S, position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt$1(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice$1(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; + }; + + var stringMultibyte = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod$3(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod$3(true) + }; + + var charAt = stringMultibyte.charAt; + var toString$3 = toString$5; + var InternalStateModule$2 = internalState; + var defineIterator$1 = iteratorDefine; + var createIterResultObject$1 = createIterResultObject$3; + + var STRING_ITERATOR = 'String Iterator'; + var setInternalState$2 = InternalStateModule$2.set; + var getInternalState = InternalStateModule$2.getterFor(STRING_ITERATOR); + + // `String.prototype[@@iterator]` method + // https://tc39.es/ecma262/#sec-string.prototype-@@iterator + defineIterator$1(String, 'String', function (iterated) { + setInternalState$2(this, { + type: STRING_ITERATOR, + string: toString$3(iterated), + index: 0 + }); + // `%StringIteratorPrototype%.next` method + // https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next + }, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return createIterResultObject$1(undefined, true); + point = charAt(string, index); + state.index += point.length; + return createIterResultObject$1(point, false); + }); + + var internalMetadata = {exports: {}}; + + var objectGetOwnPropertyNamesExternal = {}; + + var toPropertyKey = toPropertyKey$3; + var definePropertyModule = objectDefineProperty; + var createPropertyDescriptor = createPropertyDescriptor$4; + + var createProperty$4 = function (object, key, value) { + var propertyKey = toPropertyKey(key); + if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value)); + else object[propertyKey] = value; + }; + + var toAbsoluteIndex$1 = toAbsoluteIndex$3; + var lengthOfArrayLike$5 = lengthOfArrayLike$8; + var createProperty$3 = createProperty$4; + + var $Array$3 = Array; + var max$1 = Math.max; + + var arraySliceSimple = function (O, start, end) { + var length = lengthOfArrayLike$5(O); + var k = toAbsoluteIndex$1(start, length); + var fin = toAbsoluteIndex$1(end === undefined ? length : end, length); + var result = $Array$3(max$1(fin - k, 0)); + var n = 0; + for (; k < fin; k++, n++) createProperty$3(result, n, O[k]); + result.length = n; + return result; + }; + + /* eslint-disable es/no-object-getownpropertynames -- safe */ + var classof$3 = classofRaw$2; + var toIndexedObject$3 = toIndexedObject$9; + var $getOwnPropertyNames = objectGetOwnPropertyNames.f; + var arraySlice$1 = arraySliceSimple; + + var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + + var getWindowNames = function (it) { + try { + return $getOwnPropertyNames(it); + } catch (error) { + return arraySlice$1(windowNames); + } + }; + + // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window + objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames(it) { + return windowNames && classof$3(it) === 'Window' + ? getWindowNames(it) + : $getOwnPropertyNames(toIndexedObject$3(it)); + }; + + // FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it + var fails$b = fails$p; + + var arrayBufferNonExtensible = fails$b(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } + }); + + var fails$a = fails$p; + var isObject$9 = isObject$i; + var classof$2 = classofRaw$2; + var ARRAY_BUFFER_NON_EXTENSIBLE = arrayBufferNonExtensible; + + // eslint-disable-next-line es/no-object-isextensible -- safe + var $isExtensible = Object.isExtensible; + var FAILS_ON_PRIMITIVES$1 = fails$a(function () { $isExtensible(1); }); + + // `Object.isExtensible` method + // https://tc39.es/ecma262/#sec-object.isextensible + var objectIsExtensible = (FAILS_ON_PRIMITIVES$1 || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) { + if (!isObject$9(it)) return false; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof$2(it) === 'ArrayBuffer') return false; + return $isExtensible ? $isExtensible(it) : true; + } : $isExtensible; + + var fails$9 = fails$p; + + var freezing = !fails$9(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); + }); + + var $$e = _export; + var uncurryThis$8 = functionUncurryThis; + var hiddenKeys = hiddenKeys$5; + var isObject$8 = isObject$i; + var hasOwn$1 = hasOwnProperty_1; + var defineProperty = objectDefineProperty.f; + var getOwnPropertyNamesModule = objectGetOwnPropertyNames; + var getOwnPropertyNamesExternalModule = objectGetOwnPropertyNamesExternal; + var isExtensible = objectIsExtensible; + var uid = uid$3; + var FREEZING = freezing; + + var REQUIRED = false; + var METADATA = uid('meta'); + var id$1 = 0; + + var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + id$1++, // object ID + weakData: {} // weak collections IDs + } }); + }; + + var fastKey$1 = function (it, create) { + // return a primitive with prefix + if (!isObject$8(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; + }; + + var getWeakData$1 = function (it, create) { + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; + }; + + // add metadata on freeze-family methods calling + var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn$1(it, METADATA)) setMetadata(it); + return it; + }; + + var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis$8([].splice); + var test = {}; + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $$e({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } + }; + + var meta = internalMetadata.exports = { + enable: enable, + fastKey: fastKey$1, + getWeakData: getWeakData$1, + onFreeze: onFreeze + }; + + hiddenKeys[METADATA] = true; + + var internalMetadataExports = internalMetadata.exports; + + var isCallable$1 = isCallable$m; + var isObject$7 = isObject$i; + var setPrototypeOf = objectSetPrototypeOf; + + // makes subclassing work correct for wrapped built-ins + var inheritIfRequired$1 = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable$1(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject$7(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; + }; + + var $$d = _export; + var global$3 = global$k; + var uncurryThis$7 = functionUncurryThis; + var isForced = isForced_1; + var defineBuiltIn$1 = defineBuiltIn$8; + var InternalMetadataModule = internalMetadataExports; + var iterate$3 = iterate$6; + var anInstance$2 = anInstance$4; + var isCallable = isCallable$m; + var isNullOrUndefined$2 = isNullOrUndefined$7; + var isObject$6 = isObject$i; + var fails$8 = fails$p; + var checkCorrectnessOfIteration$1 = checkCorrectnessOfIteration$3; + var setToStringTag$1 = setToStringTag$5; + var inheritIfRequired = inheritIfRequired$1; + + var collection$2 = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global$3[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis$7(NativePrototype[KEY]); + defineBuiltIn$1(NativePrototype, KEY, + KEY === 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY === 'delete' ? function (key) { + return IS_WEAK && !isObject$6(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'get' ? function get(key) { + return IS_WEAK && !isObject$6(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'has' ? function has(key) { + return IS_WEAK && !isObject$6(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails$8(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails$8(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration$1(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails$8(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance$2(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (!isNullOrUndefined$2(iterable)) iterate$3(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $$d({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported); + + setToStringTag$1(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; + }; + + var defineBuiltIn = defineBuiltIn$8; + + var defineBuiltIns$2 = function (target, src, options) { + for (var key in src) defineBuiltIn(target, key, src[key], options); + return target; + }; + + var classof$1 = classofRaw$2; + + // `IsArray` abstract operation + // https://tc39.es/ecma262/#sec-isarray + // eslint-disable-next-line es/no-array-isarray -- safe + var isArray$3 = Array.isArray || function isArray(argument) { + return classof$1(argument) === 'Array'; + }; + + var isArray$2 = isArray$3; + var isConstructor$2 = isConstructor$4; + var isObject$5 = isObject$i; + var wellKnownSymbol$6 = wellKnownSymbol$k; + + var SPECIES$2 = wellKnownSymbol$6('species'); + var $Array$2 = Array; + + // a part of `ArraySpeciesCreate` abstract operation + // https://tc39.es/ecma262/#sec-arrayspeciescreate + var arraySpeciesConstructor$1 = function (originalArray) { + var C; + if (isArray$2(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor$2(C) && (C === $Array$2 || isArray$2(C.prototype))) C = undefined; + else if (isObject$5(C)) { + C = C[SPECIES$2]; + if (C === null) C = undefined; + } + } return C === undefined ? $Array$2 : C; + }; + + var arraySpeciesConstructor = arraySpeciesConstructor$1; + + // `ArraySpeciesCreate` abstract operation + // https://tc39.es/ecma262/#sec-arrayspeciescreate + var arraySpeciesCreate$2 = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); + }; + + var bind$2 = functionBindContext; + var uncurryThis$6 = functionUncurryThis; + var IndexedObject$1 = indexedObject; + var toObject$4 = toObject$8; + var lengthOfArrayLike$4 = lengthOfArrayLike$8; + var arraySpeciesCreate$1 = arraySpeciesCreate$2; + + var push$2 = uncurryThis$6([].push); + + // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation + var createMethod$2 = function (TYPE) { + var IS_MAP = TYPE === 1; + var IS_FILTER = TYPE === 2; + var IS_SOME = TYPE === 3; + var IS_EVERY = TYPE === 4; + var IS_FIND_INDEX = TYPE === 6; + var IS_FILTER_REJECT = TYPE === 7; + var NO_HOLES = TYPE === 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject$4($this); + var self = IndexedObject$1(O); + var length = lengthOfArrayLike$4(self); + var boundFunction = bind$2(callbackfn, that); + var index = 0; + var create = specificCreate || arraySpeciesCreate$1; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push$2(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push$2(target, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; + }; + + var arrayIteration = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod$2(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod$2(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod$2(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod$2(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod$2(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod$2(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod$2(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod$2(7) + }; + + var uncurryThis$5 = functionUncurryThis; + var defineBuiltIns$1 = defineBuiltIns$2; + var getWeakData = internalMetadataExports.getWeakData; + var anInstance$1 = anInstance$4; + var anObject$1 = anObject$c; + var isNullOrUndefined$1 = isNullOrUndefined$7; + var isObject$4 = isObject$i; + var iterate$2 = iterate$6; + var ArrayIterationModule = arrayIteration; + var hasOwn = hasOwnProperty_1; + var InternalStateModule$1 = internalState; + + var setInternalState$1 = InternalStateModule$1.set; + var internalStateGetterFor$1 = InternalStateModule$1.getterFor; + var find = ArrayIterationModule.find; + var findIndex = ArrayIterationModule.findIndex; + var splice = uncurryThis$5([].splice); + var id = 0; + + // fallback for uncaught frozen keys + var uncaughtFrozenStore = function (state) { + return state.frozen || (state.frozen = new UncaughtFrozenStore()); + }; + + var UncaughtFrozenStore = function () { + this.entries = []; + }; + + var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); + }; + + UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) splice(this.entries, index, 1); + return !!~index; + } + }; + + var collectionWeak$1 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance$1(that, Prototype); + setInternalState$1(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (!isNullOrUndefined$1(iterable)) iterate$2(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor$1(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject$1(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + defineBuiltIns$1(Prototype, { + // `{ WeakMap, WeakSet }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.delete + // https://tc39.es/ecma262/#sec-weakset.prototype.delete + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject$4(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && hasOwn(data, state.id) && delete data[state.id]; + }, + // `{ WeakMap, WeakSet }.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.has + // https://tc39.es/ecma262/#sec-weakset.prototype.has + has: function has(key) { + var state = getInternalState(this); + if (!isObject$4(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && hasOwn(data, state.id); + } + }); + + defineBuiltIns$1(Prototype, IS_MAP ? { + // `WeakMap.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.get + get: function get(key) { + var state = getInternalState(this); + if (isObject$4(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // `WeakMap.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.set + set: function set(key, value) { + return define(this, key, value); + } + } : { + // `WeakSet.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-weakset.prototype.add + add: function add(value) { + return define(this, value, true); + } + }); + + return Constructor; + } + }; + + var collection$1 = collection$2; + var collectionWeak = collectionWeak$1; + + // `WeakSet` constructor + // https://tc39.es/ecma262/#sec-weakset-constructor + collection$1('WeakSet', function (init) { + return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); }; + }, collectionWeak); + + // iterable DOM collections + // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods + var domIterables = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 + }; + + // in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList` + var documentCreateElement = documentCreateElement$2; + + var classList = documentCreateElement('span').classList; + var DOMTokenListPrototype$2 = classList && classList.constructor && classList.constructor.prototype; + + var domTokenListPrototype = DOMTokenListPrototype$2 === Object.prototype ? undefined : DOMTokenListPrototype$2; + + var global$2 = global$k; + var DOMIterables$1 = domIterables; + var DOMTokenListPrototype$1 = domTokenListPrototype; + var ArrayIteratorMethods = es_array_iterator; + var createNonEnumerableProperty$1 = createNonEnumerableProperty$5; + var setToStringTag = setToStringTag$5; + var wellKnownSymbol$5 = wellKnownSymbol$k; + + var ITERATOR = wellKnownSymbol$5('iterator'); + var ArrayValues = ArrayIteratorMethods.values; + + var handlePrototype$1 = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty$1(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + setToStringTag(CollectionPrototype, COLLECTION_NAME, true); + if (DOMIterables$1[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty$1(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } + }; + + for (var COLLECTION_NAME$1 in DOMIterables$1) { + handlePrototype$1(global$2[COLLECTION_NAME$1] && global$2[COLLECTION_NAME$1].prototype, COLLECTION_NAME$1); + } + + handlePrototype$1(DOMTokenListPrototype$1, 'DOMTokenList'); + + var fails$7 = fails$p; + var wellKnownSymbol$4 = wellKnownSymbol$k; + var V8_VERSION$1 = engineV8Version; + + var SPECIES$1 = wellKnownSymbol$4('species'); + + var arrayMethodHasSpeciesSupport$4 = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return V8_VERSION$1 >= 51 || !fails$7(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES$1] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); + }; + + var $$c = _export; + var isArray$1 = isArray$3; + var isConstructor$1 = isConstructor$4; + var isObject$3 = isObject$i; + var toAbsoluteIndex = toAbsoluteIndex$3; + var lengthOfArrayLike$3 = lengthOfArrayLike$8; + var toIndexedObject$2 = toIndexedObject$9; + var createProperty$2 = createProperty$4; + var wellKnownSymbol$3 = wellKnownSymbol$k; + var arrayMethodHasSpeciesSupport$3 = arrayMethodHasSpeciesSupport$4; + var nativeSlice = arraySlice$3; + + var HAS_SPECIES_SUPPORT$2 = arrayMethodHasSpeciesSupport$3('slice'); + + var SPECIES = wellKnownSymbol$3('species'); + var $Array$1 = Array; + var max = Math.max; + + // `Array.prototype.slice` method + // https://tc39.es/ecma262/#sec-array.prototype.slice + // fallback for not array-like ES3 strings and DOM objects + $$c({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$2 }, { + slice: function slice(start, end) { + var O = toIndexedObject$2(this); + var length = lengthOfArrayLike$3(O); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible + var Constructor, result, n; + if (isArray$1(O)) { + Constructor = O.constructor; + // cross-realm fallback + if (isConstructor$1(Constructor) && (Constructor === $Array$1 || isArray$1(Constructor.prototype))) { + Constructor = undefined; + } else if (isObject$3(Constructor)) { + Constructor = Constructor[SPECIES]; + if (Constructor === null) Constructor = undefined; + } + if (Constructor === $Array$1 || Constructor === undefined) { + return nativeSlice(O, k, fin); + } + } + result = new (Constructor === undefined ? $Array$1 : Constructor)(max(fin - k, 0)); + for (n = 0; k < fin; k++, n++) if (k in O) createProperty$2(result, n, O[k]); + result.length = n; + return result; + } + }); + + var fails$6 = fails$p; + + var arrayMethodIsStrict$3 = function (METHOD_NAME, argument) { + var method = [][METHOD_NAME]; + return !!method && fails$6(function () { + // eslint-disable-next-line no-useless-call -- required for testing + method.call(null, argument || function () { return 1; }, 1); + }); + }; + + var $$b = _export; + var uncurryThis$4 = functionUncurryThis; + var IndexedObject = indexedObject; + var toIndexedObject$1 = toIndexedObject$9; + var arrayMethodIsStrict$2 = arrayMethodIsStrict$3; + + var nativeJoin = uncurryThis$4([].join); + + var ES3_STRINGS = IndexedObject !== Object; + var FORCED$2 = ES3_STRINGS || !arrayMethodIsStrict$2('join', ','); + + // `Array.prototype.join` method + // https://tc39.es/ecma262/#sec-array.prototype.join + $$b({ target: 'Array', proto: true, forced: FORCED$2 }, { + join: function join(separator) { + return nativeJoin(toIndexedObject$1(this), separator === undefined ? ',' : separator); + } + }); + + /****************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + /* global Reflect, Promise */ + + + function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); + } + + var $$a = _export; + var toObject$3 = toObject$8; + var nativeKeys = objectKeys$3; + var fails$5 = fails$p; + + var FAILS_ON_PRIMITIVES = fails$5(function () { nativeKeys(1); }); + + // `Object.keys` method + // https://tc39.es/ecma262/#sec-object.keys + $$a({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, { + keys: function keys(it) { + return nativeKeys(toObject$3(it)); + } + }); + + var isObject$2 = isObject$i; + var classof = classofRaw$2; + var wellKnownSymbol$2 = wellKnownSymbol$k; + + var MATCH$1 = wellKnownSymbol$2('match'); + + // `IsRegExp` abstract operation + // https://tc39.es/ecma262/#sec-isregexp + var isRegexp = function (it) { + var isRegExp; + return isObject$2(it) && ((isRegExp = it[MATCH$1]) !== undefined ? !!isRegExp : classof(it) === 'RegExp'); + }; + + var isRegExp = isRegexp; + + var $TypeError$2 = TypeError; + + var notARegexp = function (it) { + if (isRegExp(it)) { + throw new $TypeError$2("The method doesn't accept regular expressions"); + } return it; + }; + + var wellKnownSymbol$1 = wellKnownSymbol$k; + + var MATCH = wellKnownSymbol$1('match'); + + var correctIsRegexpLogic = function (METHOD_NAME) { + var regexp = /./; + try { + '/./'[METHOD_NAME](regexp); + } catch (error1) { + try { + regexp[MATCH] = false; + return '/./'[METHOD_NAME](regexp); + } catch (error2) { /* empty */ } + } return false; + }; + + var $$9 = _export; + var uncurryThis$3 = functionUncurryThisClause; + var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + var toLength = toLength$2; + var toString$2 = toString$5; + var notARegExp = notARegexp; + var requireObjectCoercible$1 = requireObjectCoercible$5; + var correctIsRegExpLogic = correctIsRegexpLogic; + + // eslint-disable-next-line es/no-string-prototype-startswith -- safe + var nativeStartsWith = uncurryThis$3(''.startsWith); + var stringSlice = uncurryThis$3(''.slice); + var min = Math.min; + + var CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith'); + // https://github.com/zloirock/core-js/pull/702 + var MDN_POLYFILL_BUG = !CORRECT_IS_REGEXP_LOGIC && !!function () { + var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith'); + return descriptor && !descriptor.writable; + }(); + + // `String.prototype.startsWith` method + // https://tc39.es/ecma262/#sec-string.prototype.startswith + $$9({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, { + startsWith: function startsWith(searchString /* , position = 0 */) { + var that = toString$2(requireObjectCoercible$1(this)); + notARegExp(searchString); + var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length)); + var search = toString$2(searchString); + return nativeStartsWith + ? nativeStartsWith(that, search, index) + : stringSlice(that, index, index + search.length) === search; + } + }); + + var $forEach = arrayIteration.forEach; + var arrayMethodIsStrict$1 = arrayMethodIsStrict$3; + + var STRICT_METHOD$1 = arrayMethodIsStrict$1('forEach'); + + // `Array.prototype.forEach` method implementation + // https://tc39.es/ecma262/#sec-array.prototype.foreach + var arrayForEach = !STRICT_METHOD$1 ? function forEach(callbackfn /* , thisArg */) { + return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + // eslint-disable-next-line es/no-array-prototype-foreach -- safe + } : [].forEach; + + var global$1 = global$k; + var DOMIterables = domIterables; + var DOMTokenListPrototype = domTokenListPrototype; + var forEach = arrayForEach; + var createNonEnumerableProperty = createNonEnumerableProperty$5; + + var handlePrototype = function (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try { + createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach); + } catch (error) { + CollectionPrototype.forEach = forEach; + } + }; + + for (var COLLECTION_NAME in DOMIterables) { + if (DOMIterables[COLLECTION_NAME]) { + handlePrototype(global$1[COLLECTION_NAME] && global$1[COLLECTION_NAME].prototype); + } + } + + handlePrototype(DOMTokenListPrototype); + + var DESCRIPTORS$1 = descriptors; + var fails$4 = fails$p; + var uncurryThis$2 = functionUncurryThis; + var objectGetPrototypeOf = objectGetPrototypeOf$1; + var objectKeys = objectKeys$3; + var toIndexedObject = toIndexedObject$9; + var $propertyIsEnumerable = objectPropertyIsEnumerable.f; + + var propertyIsEnumerable = uncurryThis$2($propertyIsEnumerable); + var push$1 = uncurryThis$2([].push); + + // in some IE versions, `propertyIsEnumerable` returns incorrect result on integer keys + // of `null` prototype objects + var IE_BUG = DESCRIPTORS$1 && fails$4(function () { + // eslint-disable-next-line es/no-object-create -- safe + var O = Object.create(null); + O[2] = 2; + return !propertyIsEnumerable(O, 2); + }); + + // `Object.{ entries, values }` methods implementation + var createMethod$1 = function (TO_ENTRIES) { + return function (it) { + var O = toIndexedObject(it); + var keys = objectKeys(O); + var IE_WORKAROUND = IE_BUG && objectGetPrototypeOf(O) === null; + var length = keys.length; + var i = 0; + var result = []; + var key; + while (length > i) { + key = keys[i++]; + if (!DESCRIPTORS$1 || (IE_WORKAROUND ? key in O : propertyIsEnumerable(O, key))) { + push$1(result, TO_ENTRIES ? [key, O[key]] : O[key]); + } + } + return result; + }; + }; + + var objectToArray = { + // `Object.entries` method + // https://tc39.es/ecma262/#sec-object.entries + entries: createMethod$1(true), + // `Object.values` method + // https://tc39.es/ecma262/#sec-object.values + values: createMethod$1(false) + }; + + var $$8 = _export; + var $entries = objectToArray.entries; + + // `Object.entries` method + // https://tc39.es/ecma262/#sec-object.entries + $$8({ target: 'Object', stat: true }, { + entries: function entries(O) { + return $entries(O); + } + }); + + function defined(x) { + return x != null && !Number.isNaN(x); + } + + function ascendingDefined(a, b) { + return +defined(b) - +defined(a) || d3.ascending(a, b); + } + + function finite(x) { + return isFinite(x) ? x : NaN; + } + + function positive(x) { + return x > 0 && isFinite(x) ? x : NaN; + } + + function negative(x) { + return x < 0 && isFinite(x) ? x : NaN; + } + + const re = /^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/; + + function parse(string, fallback) { + if (!re.test(string += "")) return typeof fallback === "function" ? fallback(string) : fallback; + return new Date(string); + } + + const timeIntervals = new Map([ + ["second", d3.timeSecond], + ["minute", d3.timeMinute], + ["hour", d3.timeHour], + ["day", d3.timeDay], + ["week", d3.timeWeek], + ["month", d3.timeMonth], + ["quarter", d3.timeMonth.every(3)], + ["half", d3.timeMonth.every(6)], + ["year", d3.timeYear], + ["monday", d3.timeMonday], + ["tuesday", d3.timeTuesday], + ["wednesday", d3.timeWednesday], + ["thursday", d3.timeThursday], + ["friday", d3.timeFriday], + ["saturday", d3.timeSaturday], + ["sunday", d3.timeSunday] + ]); + + const utcIntervals = new Map([ + ["second", d3.utcSecond], + ["minute", d3.utcMinute], + ["hour", d3.utcHour], + ["day", d3.utcDay], + ["week", d3.utcWeek], + ["month", d3.utcMonth], + ["quarter", d3.utcMonth.every(3)], + ["half", d3.utcMonth.every(6)], + ["year", d3.utcYear], + ["monday", d3.utcMonday], + ["tuesday", d3.utcTuesday], + ["wednesday", d3.utcWednesday], + ["thursday", d3.utcThursday], + ["friday", d3.utcFriday], + ["saturday", d3.utcSaturday], + ["sunday", d3.utcSunday] + ]); + + function maybeTimeInterval(interval) { + const i = timeIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; + } + + function maybeUtcInterval(interval) { + const i = utcIntervals.get(`${interval}`.toLowerCase()); + if (!i) throw new Error(`unknown interval: ${interval}`); + return i; + } + + // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray + const TypedArray = Object.getPrototypeOf(Uint8Array); + const objectToString = Object.prototype.toString; + const constant = (x) => () => x; + + // If the values are specified as a typed array, no coercion is required. + function coerceNumbers(values) { + return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array); + } + + // Unlike Mark’s number, here we want to convert null and undefined to NaN since + // the result will be stored in a Float64Array and we don’t want null to be + // coerced to zero. We use Number instead of unary + to allow BigInt coercion. + function coerceNumber(x) { + return x == null ? NaN : Number(x); + } + + function coerceDates(values) { + return map(values, coerceDate); + } + + // When coercing strings to dates, we only want to allow the ISO 8601 format + // since the built-in string parsing of the Date constructor varies across + // browsers. (In the future, this could be made more liberal if desired, though + // it is still generally preferable to do date parsing yourself explicitly, + // rather than rely on Plot.) Any non-string values are coerced to number first + // and treated as milliseconds since UNIX epoch. + function coerceDate(x) { + return x instanceof Date && !isNaN(x) + ? x + : typeof x === "string" + ? parse(x) + : x == null || isNaN((x = +x)) + ? undefined + : new Date(x); + } + + // Promotes the specified data to an array as needed. + function arrayify(data) { + return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data); + } + + // An optimization of type.from(values, f): if the given values are already an + // instanceof the desired array type, the faster values.map method is used. + function map(values, f, type = Array) { + return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f); + } + + // An optimization of type.from(values): if the given values are already an + // instanceof the desired array type, the faster values.slice method is used. + function slice(values, type = Array) { + return values instanceof type ? values.slice() : type.from(values); + } + + // Disambiguates an options object (e.g., {y: "x2"}) from a primitive value. + function isObject$1(option) { + return option?.toString === objectToString; + } + + // Disambiguates a scale options object (e.g., {color: {type: "linear"}}) from + // some other option (e.g., {color: "red"}). When creating standalone legends, + // this is used to test whether a scale is defined; this should be consistent + // with inferScaleType when there are no channels associated with the scale, and + // if this returns true, then normalizeScale must return non-null. + function isScaleOptions(option) { + return isObject$1(option) && (option.type !== undefined || option.domain !== undefined); + } + + // If interval is not nullish, converts interval shorthand such as a number (for + // multiples) or a time interval name (such as “day”) to a {floor, offset, + // range} object similar to a D3 time interval. + function maybeInterval(interval, type) { + if (interval == null) return; + if (typeof interval === "number") { + if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval; + const n = Math.abs(interval); + return interval < 0 + ? { + floor: (d) => Math.floor(d * n) / n, + offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity + range: (lo, hi) => d3.range(Math.ceil(lo * n), hi * n).map((x) => x / n) + } + : { + floor: (d) => Math.floor(d / n) * n, + offset: (d) => d + n, // note: no optional step for simplicity + range: (lo, hi) => d3.range(Math.ceil(lo / n), hi / n).map((x) => x * n) + }; + } + if (typeof interval === "string") return (type === "time" ? maybeTimeInterval : maybeUtcInterval)(interval); + if (typeof interval.floor !== "function") throw new Error("invalid interval; missing floor method"); + if (typeof interval.offset !== "function") throw new Error("invalid interval; missing offset method"); + return interval; + } + + // Like maybeInterval, but requires a range method too. + function maybeRangeInterval(interval, type) { + interval = maybeInterval(interval, type); + if (interval && typeof interval.range !== "function") throw new Error("invalid interval: missing range method"); + return interval; + } + + // Like maybeRangeInterval, but requires a ceil method too. + function maybeNiceInterval(interval, type) { + interval = maybeRangeInterval(interval, type); + if (interval && typeof interval.ceil !== "function") throw new Error("invalid interval: missing ceil method"); + return interval; + } + + function isOrdinal(values) { + for (const value of values) { + if (value == null) continue; + const type = typeof value; + return type === "string" || type === "boolean"; + } + } + + function isTemporal(values) { + for (const value of values) { + if (value == null) continue; + return value instanceof Date; + } + } + + // Are these strings that might represent dates? This is stricter than ISO 8601 + // because we want to ignore false positives on numbers; for example, the string + // "1192" is more likely to represent a number than a date even though it is + // valid ISO 8601 representing 1192-01-01. + function isTemporalString(values) { + for (const value of values) { + if (value == null) continue; + return typeof value === "string" && isNaN(value) && parse(value); + } + } + + // Are these strings that might represent numbers? This is stricter than + // coercion because we want to ignore false positives on e.g. empty strings. + function isNumericString(values) { + for (const value of values) { + if (value == null) continue; + if (typeof value !== "string") return false; + if (!value.trim()) continue; + return !isNaN(value); + } + } + + function isNoneish(value) { + return value == null || isNone(value); + } + + function isNone(value) { + return /^\s*none\s*$/i.test(value); + } + + // Like a sort comparator, returns a positive value if the given array of values + // is in ascending order, a negative value if the values are in descending + // order. Assumes monotonicity; only tests the first and last values. + function orderof(values) { + if (values == null) return; + const first = values[0]; + const last = values[values.length - 1]; + return d3.descending(first, last); + } + + // Positional scales have associated axes, and for ordinal data, a point or band + // scale is used instead of an ordinal scale. + const position = Symbol("position"); + + // Color scales default to the turbo interpolator for quantitative data, and to + // the Tableau10 scheme for ordinal data. Color scales may also have an + // associated legend. + const color = Symbol("color"); + + // Radius scales default to the sqrt type, have a default range of [0, 3], and a + // default domain from 0 to the median first quartile of associated channels. + const radius = Symbol("radius"); + + // Length scales default to the linear type, have a default range of [0, 12], + // and a default domain from 0 to the median median of associated channels. + const length = Symbol("length"); + + // Opacity scales have a default range of [0, 1], and a default domain from 0 to + // the maximum value of associated channels. + const opacity = Symbol("opacity"); + + // Symbol scales have a default range of categorical symbols. + const symbol = Symbol("symbol"); + + // TODO Rather than hard-coding the list of known scale names, collect the names + // and categories for each plot specification, so that custom marks can register + // custom scales. + const registry = new Map([ + ["x", position], + ["y", position], + ["fx", position], + ["fy", position], + ["r", radius], + ["color", color], + ["opacity", opacity], + ["symbol", symbol], + ["length", length] + ]); + + const sqrt3 = Math.sqrt(3); + const sqrt4_3 = 2 / sqrt3; + + const symbolHexagon = { + draw(context, size) { + const rx = Math.sqrt(size / Math.PI), + ry = rx * sqrt4_3, + hy = ry / 2; + context.moveTo(0, ry); + context.lineTo(rx, hy); + context.lineTo(rx, -hy); + context.lineTo(0, -ry); + context.lineTo(-rx, -hy); + context.lineTo(-rx, hy); + context.closePath(); + } + }; + + const symbols = new Map([ + ["asterisk", d3.symbolAsterisk], + ["circle", d3.symbolCircle], + ["cross", d3.symbolCross], + ["diamond", d3.symbolDiamond], + ["diamond2", d3.symbolDiamond2], + ["hexagon", symbolHexagon], + ["plus", d3.symbolPlus], + ["square", d3.symbolSquare], + ["square2", d3.symbolSquare2], + ["star", d3.symbolStar], + ["times", d3.symbolTimes], + ["triangle", d3.symbolTriangle], + ["triangle2", d3.symbolTriangle2], + ["wye", d3.symbolWye] + ]); + + function isSymbolObject(value) { + return value && typeof value.draw === "function"; + } + + function maybeSymbol(symbol) { + if (symbol == null || isSymbolObject(symbol)) return symbol; + const value = symbols.get(`${symbol}`.toLowerCase()); + if (value) return value; + throw new Error(`invalid symbol: ${symbol}`); + } + + function warn(message) { + console.warn(message); + } + + const ordinalSchemes = new Map([ + // categorical + ["accent", d3.schemeAccent], + ["category10", d3.schemeCategory10], + ["dark2", d3.schemeDark2], + ["paired", d3.schemePaired], + ["pastel1", d3.schemePastel1], + ["pastel2", d3.schemePastel2], + ["set1", d3.schemeSet1], + ["set2", d3.schemeSet2], + ["set3", d3.schemeSet3], + ["tableau10", d3.schemeTableau10], + + // diverging + ["brbg", scheme11(d3.schemeBrBG, d3.interpolateBrBG)], + ["prgn", scheme11(d3.schemePRGn, d3.interpolatePRGn)], + ["piyg", scheme11(d3.schemePiYG, d3.interpolatePiYG)], + ["puor", scheme11(d3.schemePuOr, d3.interpolatePuOr)], + ["rdbu", scheme11(d3.schemeRdBu, d3.interpolateRdBu)], + ["rdgy", scheme11(d3.schemeRdGy, d3.interpolateRdGy)], + ["rdylbu", scheme11(d3.schemeRdYlBu, d3.interpolateRdYlBu)], + ["rdylgn", scheme11(d3.schemeRdYlGn, d3.interpolateRdYlGn)], + ["spectral", scheme11(d3.schemeSpectral, d3.interpolateSpectral)], + + // reversed diverging (for temperature data) + ["burd", scheme11r(d3.schemeRdBu, d3.interpolateRdBu)], + ["buylrd", scheme11r(d3.schemeRdYlBu, d3.interpolateRdYlBu)], + + // sequential (single-hue) + ["blues", scheme9(d3.schemeBlues, d3.interpolateBlues)], + ["greens", scheme9(d3.schemeGreens, d3.interpolateGreens)], + ["greys", scheme9(d3.schemeGreys, d3.interpolateGreys)], + ["oranges", scheme9(d3.schemeOranges, d3.interpolateOranges)], + ["purples", scheme9(d3.schemePurples, d3.interpolatePurples)], + ["reds", scheme9(d3.schemeReds, d3.interpolateReds)], + + // sequential (multi-hue) + ["turbo", schemei(d3.interpolateTurbo)], + ["viridis", schemei(d3.interpolateViridis)], + ["magma", schemei(d3.interpolateMagma)], + ["inferno", schemei(d3.interpolateInferno)], + ["plasma", schemei(d3.interpolatePlasma)], + ["cividis", schemei(d3.interpolateCividis)], + ["cubehelix", schemei(d3.interpolateCubehelixDefault)], + ["warm", schemei(d3.interpolateWarm)], + ["cool", schemei(d3.interpolateCool)], + ["bugn", scheme9(d3.schemeBuGn, d3.interpolateBuGn)], + ["bupu", scheme9(d3.schemeBuPu, d3.interpolateBuPu)], + ["gnbu", scheme9(d3.schemeGnBu, d3.interpolateGnBu)], + ["orrd", scheme9(d3.schemeOrRd, d3.interpolateOrRd)], + ["pubu", scheme9(d3.schemePuBu, d3.interpolatePuBu)], + ["pubugn", scheme9(d3.schemePuBuGn, d3.interpolatePuBuGn)], + ["purd", scheme9(d3.schemePuRd, d3.interpolatePuRd)], + ["rdpu", scheme9(d3.schemeRdPu, d3.interpolateRdPu)], + ["ylgn", scheme9(d3.schemeYlGn, d3.interpolateYlGn)], + ["ylgnbu", scheme9(d3.schemeYlGnBu, d3.interpolateYlGnBu)], + ["ylorbr", scheme9(d3.schemeYlOrBr, d3.interpolateYlOrBr)], + ["ylorrd", scheme9(d3.schemeYlOrRd, d3.interpolateYlOrRd)], + + // cyclical + ["rainbow", schemeicyclical(d3.interpolateRainbow)], + ["sinebow", schemeicyclical(d3.interpolateSinebow)] + ]); + + function scheme9(scheme, interpolate) { + return ({length: n}) => { + if (n === 1) return [scheme[3][1]]; // favor midpoint + if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker + n = Math.max(3, Math.floor(n)); + return n > 9 ? d3.quantize(interpolate, n) : scheme[n]; + }; + } + + function scheme11(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? d3.quantize(interpolate, n) : scheme[n]; + }; + } + + function scheme11r(scheme, interpolate) { + return ({length: n}) => { + if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema + n = Math.max(3, Math.floor(n)); + return n > 11 ? d3.quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse(); + }; + } + + function schemei(interpolate) { + return ({length: n}) => d3.quantize(interpolate, Math.max(2, Math.floor(n))); + } + + function schemeicyclical(interpolate) { + return ({length: n}) => d3.quantize(interpolate, Math.floor(n) + 1).slice(0, -1); + } + + function ordinalScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`); + return ordinalSchemes.get(s); + } + + function ordinalRange(scheme, length) { + const s = ordinalScheme(scheme); + const r = typeof s === "function" ? s({length}) : s; + return r.length !== length ? r.slice(0, length) : r; + } + + // If the specified domain contains only booleans (ignoring null and undefined), + // returns a corresponding range where false is mapped to the low color and true + // is mapped to the high color of the specified scheme. + function maybeBooleanRange(domain, scheme = "greys") { + const range = new Set(); + const [f, t] = ordinalRange(scheme, 2); + for (const value of domain) { + if (value == null) continue; + if (value === true) range.add(t); + else if (value === false) range.add(f); + else return; + } + return [...range]; + } + + const quantitativeSchemes = new Map([ + // diverging + ["brbg", d3.interpolateBrBG], + ["prgn", d3.interpolatePRGn], + ["piyg", d3.interpolatePiYG], + ["puor", d3.interpolatePuOr], + ["rdbu", d3.interpolateRdBu], + ["rdgy", d3.interpolateRdGy], + ["rdylbu", d3.interpolateRdYlBu], + ["rdylgn", d3.interpolateRdYlGn], + ["spectral", d3.interpolateSpectral], + + // reversed diverging (for temperature data) + ["burd", (t) => d3.interpolateRdBu(1 - t)], + ["buylrd", (t) => d3.interpolateRdYlBu(1 - t)], + + // sequential (single-hue) + ["blues", d3.interpolateBlues], + ["greens", d3.interpolateGreens], + ["greys", d3.interpolateGreys], + ["purples", d3.interpolatePurples], + ["reds", d3.interpolateReds], + ["oranges", d3.interpolateOranges], + + // sequential (multi-hue) + ["turbo", d3.interpolateTurbo], + ["viridis", d3.interpolateViridis], + ["magma", d3.interpolateMagma], + ["inferno", d3.interpolateInferno], + ["plasma", d3.interpolatePlasma], + ["cividis", d3.interpolateCividis], + ["cubehelix", d3.interpolateCubehelixDefault], + ["warm", d3.interpolateWarm], + ["cool", d3.interpolateCool], + ["bugn", d3.interpolateBuGn], + ["bupu", d3.interpolateBuPu], + ["gnbu", d3.interpolateGnBu], + ["orrd", d3.interpolateOrRd], + ["pubugn", d3.interpolatePuBuGn], + ["pubu", d3.interpolatePuBu], + ["purd", d3.interpolatePuRd], + ["rdpu", d3.interpolateRdPu], + ["ylgnbu", d3.interpolateYlGnBu], + ["ylgn", d3.interpolateYlGn], + ["ylorbr", d3.interpolateYlOrBr], + ["ylorrd", d3.interpolateYlOrRd], + + // cyclical + ["rainbow", d3.interpolateRainbow], + ["sinebow", d3.interpolateSinebow] + ]); + + function quantitativeScheme(scheme) { + const s = `${scheme}`.toLowerCase(); + if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`); + return quantitativeSchemes.get(s); + } + + const divergingSchemes = new Set([ + "brbg", + "prgn", + "piyg", + "puor", + "rdbu", + "rdgy", + "rdylbu", + "rdylgn", + "spectral", + "burd", + "buylrd" + ]); + + function isDivergingScheme(scheme) { + return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase()); + } + + const flip = (i) => (t) => i(1 - t); + const unit = [0, 1]; + + const interpolators = new Map([ + // numbers + ["number", d3.interpolateNumber], + + // color spaces + ["rgb", d3.interpolateRgb], + ["hsl", d3.interpolateHsl], + ["hcl", d3.interpolateHcl], + ["lab", d3.interpolateLab] + ]); + + function maybeInterpolator(interpolate) { + const i = `${interpolate}`.toLowerCase(); + if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`); + return interpolators.get(i); + } + + function createScaleQ( + key, + scale, + channels, + { + type, + nice, + clamp, + zero, + domain = inferAutoDomain(key, channels), + unknown, + round, + scheme, + interval, + range = registry.get(key) === radius + ? inferRadialRange(channels, domain) + : registry.get(key) === length + ? inferLengthRange(channels, domain) + : registry.get(key) === opacity + ? unit + : undefined, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? d3.interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : type === "cyclical" ? "rainbow" : "turbo") + : round + ? d3.interpolateRound + : d3.interpolateNumber, + reverse + } + ) { + interval = maybeRangeInterval(interval, type); + if (type === "cyclical" || type === "sequential") type = "linear"; // shorthand for color schemes + reverse = !!reverse; + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + if (interpolate.length === 1) { + if (reverse) { + interpolate = flip(interpolate); + reverse = false; + } + if (range === undefined) { + range = Float64Array.from(domain, (_, i) => i / (domain.length - 1)); + if (range.length === 2) range = unit; // optimize common case of [0, 1] + } + scale.interpolate((range === unit ? constant : interpolatePiecewise)(interpolate)); + } else { + scale.interpolate(interpolate); + } + + // If a zero option is specified, we assume that the domain is numeric, and we + // want to ensure that the domain crosses zero. However, note that the domain + // may be reversed (descending) so we shouldn’t assume that the first value is + // smaller than the last; and also it’s possible that the domain has more than + // two values for a “poly” scale. And lastly be careful not to mutate input! + if (zero) { + const [min, max] = d3.extent(domain); + if (min > 0 || max < 0) { + domain = slice(domain); + if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0; + // [2, 1] or [-2, -1] + else domain[0] = 0; // [1, 2] or [-1, -2] + } + } + + if (reverse) domain = d3.reverse(domain); + scale.domain(domain).unknown(unknown); + if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain()); + if (range !== undefined) scale.range(range); + if (clamp) scale.clamp(clamp); + return {type, domain, range, scale, interpolate, interval}; + } + + function maybeNice(nice, type) { + return nice === true ? undefined : typeof nice === "number" ? nice : maybeNiceInterval(nice, type); + } + + function createScaleLinear(key, channels, options) { + return createScaleQ(key, d3.scaleLinear(), channels, options); + } + + function createScaleSqrt(key, channels, options) { + return createScalePow(key, channels, {...options, exponent: 0.5}); + } + + function createScalePow(key, channels, {exponent = 1, ...options}) { + return createScaleQ(key, d3.scalePow().exponent(exponent), channels, {...options, type: "pow"}); + } + + function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) { + return createScaleQ(key, d3.scaleLog().base(base), channels, {...options, domain}); + } + + function createScaleSymlog(key, channels, {constant = 1, ...options}) { + return createScaleQ(key, d3.scaleSymlog().constant(constant), channels, options); + } + + function createScaleQuantile( + key, + channels, + { + range, + quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead + n = quantiles, + scheme = "rdylbu", + domain = inferQuantileDomain(channels), + unknown, + interpolate, + reverse + } + ) { + if (range === undefined) { + range = + interpolate !== undefined + ? d3.quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } + if (domain.length > 0) { + domain = d3.scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles(); + } + return createScaleThreshold(key, channels, {domain, range, reverse, unknown}); + } + + function createScaleQuantize( + key, + channels, + { + range, + n = range === undefined ? 5 : (range = [...range]).length, + scheme = "rdylbu", + domain = inferAutoDomain(key, channels), + unknown, + interpolate, + reverse + } + ) { + const [min, max] = d3.extent(domain); + let thresholds; + if (range === undefined) { + thresholds = d3.ticks(min, max, n); // approximate number of nice, round thresholds + if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound + if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound + n = thresholds.length + 1; + range = + interpolate !== undefined + ? d3.quantize(interpolate, n) + : registry.get(key) === color + ? ordinalRange(scheme, n) + : undefined; + } else { + thresholds = d3.quantize(d3.interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range + if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types + } + if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain + return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown}); + } + + function createScaleThreshold( + key, + channels, + { + domain = [0], // explicit thresholds in ascending order + unknown, + scheme = "rdylbu", + interpolate, + range = interpolate !== undefined + ? d3.quantize(interpolate, domain.length + 1) + : registry.get(key) === color + ? ordinalRange(scheme, domain.length + 1) + : undefined, + reverse + } + ) { + domain = arrayify(domain); + const sign = orderof(domain); // preserve descending domain + if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`); + if (reverse) range = d3.reverse(range); // domain ascending, so reverse range + return { + type: "threshold", + scale: d3.scaleThreshold(sign < 0 ? d3.reverse(domain) : domain, range === undefined ? [] : range).unknown(unknown), + domain, + range + }; + } + + function isOrdered(domain, sign) { + for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) { + const s = d3.descending(d, (d = domain[i])); + if (s !== 0 && s !== sign) return false; + } + return true; + } + + function createScaleIdentity() { + return {type: "identity", scale: d3.scaleIdentity()}; + } + + function inferDomain$1(channels, f = finite) { + return channels.length + ? [ + d3.min(channels, ({value}) => (value === undefined ? value : d3.min(value, f))), + d3.max(channels, ({value}) => (value === undefined ? value : d3.max(value, f))) + ] + : [0, 1]; + } + + function inferAutoDomain(key, channels) { + const type = registry.get(key); + return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain$1)(channels); + } + + function inferZeroDomain(channels) { + return [0, channels.length ? d3.max(channels, ({value}) => (value === undefined ? value : d3.max(value, finite))) : 1]; + } + + // We don’t want the upper bound of the radial domain to be zero, as this would + // be degenerate, so we ignore nonpositive values. We also don’t want the + // maximum default radius to exceed 30px. + function inferRadialRange(channels, domain) { + const hint = channels.find(({radius}) => radius !== undefined); + if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins + const h25 = d3.quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : d3.quantile(value, 0.25, positive))); + const range = domain.map((d) => 3 * Math.sqrt(d / h25)); + const k = 30 / d3.max(range); + return k < 1 ? range.map((r) => r * k) : range; + } + + // We want a length scale’s domain to go from zero to a positive value, and to + // treat negative lengths if any as inverted vectors of equivalent magnitude. We + // also don’t want the maximum default length to exceed 60px. + function inferLengthRange(channels, domain) { + const h50 = d3.median(channels, ({value}) => (value === undefined ? NaN : d3.median(value, Math.abs))); + const range = domain.map((d) => (12 * d) / h50); + const k = 60 / d3.max(range); + return k < 1 ? range.map((r) => r * k) : range; + } + + function inferLogDomain(channels) { + for (const {value} of channels) { + if (value !== undefined) { + for (let v of value) { + if (v > 0) return inferDomain$1(channels, positive); + if (v < 0) return inferDomain$1(channels, negative); + } + } + } + return [1, 10]; + } + + function inferQuantileDomain(channels) { + const domain = []; + for (const {value} of channels) { + if (value === undefined) continue; + for (const v of value) domain.push(v); + } + return domain; + } + + function interpolatePiecewise(interpolate) { + return (i, j) => (t) => interpolate(i + t * (j - i)); + } + + function createScaleD( + key, + scale, + transform, + channels, + { + type, + nice, + clamp, + domain = inferDomain$1(channels), + unknown, + pivot = 0, + scheme, + range, + symmetric = true, + interpolate = registry.get(key) === color + ? scheme == null && range !== undefined + ? d3.interpolateRgb + : quantitativeScheme(scheme !== undefined ? scheme : "rdbu") + : d3.interpolateNumber, + reverse + } + ) { + pivot = +pivot; + let [min, max] = domain; + if (d3.descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse); + min = Math.min(min, pivot); + max = Math.max(max, pivot); + + // Sometimes interpolate is a named interpolator, such as "lab" for Lab color + // space. Other times interpolate is a function that takes two arguments and + // is used in conjunction with the range. And other times the interpolate + // function is a “fixed” interpolator on the [0, 1] interval, as when a + // color scheme such as interpolateRdBu is used. + if (typeof interpolate !== "function") { + interpolate = maybeInterpolator(interpolate); + } + + // If an explicit range is specified, promote it to a piecewise interpolator. + if (range !== undefined) { + interpolate = + interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : d3.piecewise(interpolate, range); + } + + // Reverse before normalization. + if (reverse) interpolate = flip(interpolate); + + // Normalize the interpolator for symmetric difference around the pivot. + if (symmetric) { + const mid = transform.apply(pivot); + const mindelta = mid - transform.apply(min); + const maxdelta = transform.apply(max) - mid; + if (mindelta < maxdelta) min = transform.invert(mid - maxdelta); + else if (mindelta > maxdelta) max = transform.invert(mid + mindelta); + } + + scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate); + if (clamp) scale.clamp(clamp); + if (nice) scale.nice(nice); + return {type, domain: [min, max], pivot, interpolate, scale}; + } + + function createScaleDiverging(key, channels, options) { + return createScaleD(key, d3.scaleDiverging(), transformIdentity, channels, options); + } + + function createScaleDivergingSqrt(key, channels, options) { + return createScaleDivergingPow(key, channels, {...options, exponent: 0.5}); + } + + function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) { + return createScaleD(key, d3.scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, { + ...options, + type: "diverging-pow" + }); + } + + function createScaleDivergingLog( + key, + channels, + {base = 10, pivot = 1, domain = inferDomain$1(channels, pivot < 0 ? negative : positive), ...options} + ) { + return createScaleD(key, d3.scaleDivergingLog().base((base = +base)), transformLog, channels, { + domain, + pivot, + ...options + }); + } + + function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) { + return createScaleD( + key, + d3.scaleDivergingSymlog().constant((constant = +constant)), + transformSymlog(constant), + channels, + options + ); + } + + const transformIdentity = { + apply(x) { + return x; + }, + invert(x) { + return x; + } + }; + + const transformLog = { + apply: Math.log, + invert: Math.exp + }; + + const transformSqrt = { + apply(x) { + return Math.sign(x) * Math.sqrt(Math.abs(x)); + }, + invert(x) { + return Math.sign(x) * (x * x); + } + }; + + function transformPow(exponent) { + return exponent === 0.5 + ? transformSqrt + : { + apply(x) { + return Math.sign(x) * Math.pow(Math.abs(x), exponent); + }, + invert(x) { + return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent); + } + }; + } + + function transformSymlog(constant) { + return { + apply(x) { + return Math.sign(x) * Math.log1p(Math.abs(x / constant)); + }, + invert(x) { + return Math.sign(x) * Math.expm1(Math.abs(x)) * constant; + } + }; + } + + function createScaleT(key, scale, channels, options) { + return createScaleQ(key, scale, channels, options); + } + + function createScaleTime(key, channels, options) { + return createScaleT(key, d3.scaleTime(), channels, options); + } + + function createScaleUtc(key, channels, options) { + return createScaleT(key, d3.scaleUtc(), channels, options); + } + + // This denotes an implicitly ordinal color scale: the scale type was not set, + // but the associated values are strings or booleans. If the associated defined + // values are entirely boolean, the range will default to greys. You can opt out + // of this by setting the type explicitly. + const ordinalImplicit = Symbol("ordinal"); + + function createScaleO(key, scale, channels, {type, interval, domain, range, reverse, hint}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + if (type === "categorical" || type === ordinalImplicit) type = "ordinal"; // shorthand for color schemes + if (reverse) domain = d3.reverse(domain); + scale.domain(domain); + if (range !== undefined) { + // If the range is specified as a function, pass it the domain. + if (typeof range === "function") range = range(domain); + scale.range(range); + } + return {type, domain, range, scale, hint, interval}; + } + + function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) { + interval = maybeRangeInterval(interval, type); + if (domain === undefined) domain = inferDomain(channels, interval, key); + let hint; + if (registry.get(key) === symbol) { + hint = inferSymbolHint(channels); + range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol); + } else if (registry.get(key) === color) { + if (range === undefined && (type === "ordinal" || type === ordinalImplicit)) { + range = maybeBooleanRange(domain, scheme); + if (range !== undefined) scheme = undefined; // Don’t re-apply scheme. + } + if (scheme === undefined && range === undefined) { + scheme = type === "ordinal" ? "turbo" : "tableau10"; + } + if (scheme !== undefined) { + if (range !== undefined) { + const interpolate = quantitativeScheme(scheme); + const t0 = range[0], + d = range[1] - range[0]; + range = ({length: n}) => d3.quantize((t) => interpolate(t0 + d * t), n); + } else { + range = ordinalScheme(scheme); + } + } + } + if (unknown === d3.scaleImplicit) { + throw new Error(`implicit unknown on ${key} scale is not supported`); + } + return createScaleO(key, d3.scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint}); + } + + function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) { + return maybeRound(d3.scalePoint().align(align).padding(padding), channels, options, key); + } + + function createScaleBand( + key, + channels, + { + align = 0.5, + padding = 0.1, + paddingInner = padding, + paddingOuter = key === "fx" || key === "fy" ? 0 : padding, + ...options + } + ) { + return maybeRound( + d3.scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter), + channels, + options, + key + ); + } + + function maybeRound(scale, channels, options, key) { + let {round} = options; + if (round !== undefined) scale.round((round = !!round)); + scale = createScaleO(key, scale, channels, options); + scale.round = round; // preserve for autoScaleRound + return scale; + } + + function inferDomain(channels, interval, key) { + const values = new d3.InternSet(); + for (const {value, domain} of channels) { + if (domain !== undefined) return domain(); // see channelDomain + if (value === undefined) continue; + for (const v of value) values.add(v); + } + if (interval !== undefined) { + const [min, max] = d3.extent(values).map(interval.floor, interval); + return interval.range(min, interval.offset(max)); + } + if (values.size > 10e3 && registry.get(key) === position) { + throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`); + } + return d3.sort(values, ascendingDefined); + } + + // If all channels provide a consistent hint, propagate it to the scale. + function inferHint(channels, key) { + let value; + for (const {hint} of channels) { + const candidate = hint?.[key]; + if (candidate === undefined) continue; // no hint here + if (value === undefined) value = candidate; + // first hint + else if (value !== candidate) return; // inconsistent hint + } + return value; + } + + function inferSymbolHint(channels) { + return { + fill: inferHint(channels, "fill"), + stroke: inferHint(channels, "stroke") + }; + } + + function inferSymbolRange(hint) { + return isNoneish(hint.fill) ? d3.symbolsStroke : d3.symbolsFill; + } + + function normalizeScale(key, scale, hint) { + return createScale(key, hint === undefined ? undefined : [{hint}], {...scale}); + } + + function createScale(key, channels = [], options = {}) { + const type = inferScaleType(key, channels, options); + + // Warn for common misuses of implicit ordinal scales. We disable this test if + // you specify a scale interval or if you set the domain or range explicitly, + // since setting the domain or range (typically with a cardinality of more than + // two) is another indication that you intended for the scale to be ordinal; we + // also disable it for facet scales since these are always band scales. + if ( + options.type === undefined && + options.domain === undefined && + options.range === undefined && + options.interval == null && + key !== "fx" && + key !== "fy" && + isOrdinalScale({type}) + ) { + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isTemporal)) + warn( + `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isTemporalString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${formatScaleType( + type + )}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + else if (values.some(isNumericString)) + warn( + `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${formatScaleType( + type + )}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to "${formatScaleType( + type + )}".` + ); + } + + options.type = type; // Mutates input! + + // Once the scale type is known, coerce the associated channel values and any + // explicitly-specified domain to the expected type. + switch (type) { + case "diverging": + case "diverging-sqrt": + case "diverging-pow": + case "diverging-log": + case "diverging-symlog": + case "cyclical": + case "sequential": + case "linear": + case "sqrt": + case "threshold": + case "quantile": + case "pow": + case "log": + case "symlog": + options = coerceType(channels, options, coerceNumbers); + break; + case "identity": + switch (registry.get(key)) { + case position: + options = coerceType(channels, options, coerceNumbers); + break; + case symbol: + options = coerceType(channels, options, coerceSymbols); + break; + } + break; + case "utc": + case "time": + options = coerceType(channels, options, coerceDates); + break; + } + + switch (type) { + case "diverging": + return createScaleDiverging(key, channels, options); + case "diverging-sqrt": + return createScaleDivergingSqrt(key, channels, options); + case "diverging-pow": + return createScaleDivergingPow(key, channels, options); + case "diverging-log": + return createScaleDivergingLog(key, channels, options); + case "diverging-symlog": + return createScaleDivergingSymlog(key, channels, options); + case "categorical": + case "ordinal": + case ordinalImplicit: + return createScaleOrdinal(key, channels, options); + case "cyclical": + case "sequential": + case "linear": + return createScaleLinear(key, channels, options); + case "sqrt": + return createScaleSqrt(key, channels, options); + case "threshold": + return createScaleThreshold(key, channels, options); + case "quantile": + return createScaleQuantile(key, channels, options); + case "quantize": + return createScaleQuantize(key, channels, options); + case "pow": + return createScalePow(key, channels, options); + case "log": + return createScaleLog(key, channels, options); + case "symlog": + return createScaleSymlog(key, channels, options); + case "utc": + return createScaleUtc(key, channels, options); + case "time": + return createScaleTime(key, channels, options); + case "point": + return createScalePoint(key, channels, options); + case "band": + return createScaleBand(key, channels, options); + case "identity": + return registry.get(key) === position ? createScaleIdentity() : {type: "identity"}; + case undefined: + return; + default: + throw new Error(`unknown scale type: ${type}`); + } + } + + function formatScaleType(type) { + return typeof type === "symbol" ? type.description : type; + } + + // A special type symbol when the x and y scales are replaced with a projection. + const typeProjection = {toString: () => "projection"}; + + function inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) { + // The facet scales are always band scales; this cannot be changed. + if (key === "fx" || key === "fy") return "band"; + + // If a projection is specified, the x- and y-scales are disabled; these + // channels will be projected rather than scaled. (But still check that none + // of the associated channels are incompatible with a projection.) + if ((key === "x" || key === "y") && projection != null) type = typeProjection; + + // If a channel dictates a scale type, make sure that it is consistent with + // the user-specified scale type (if any) and all other channels. For example, + // barY requires x to be a band scale and disallows any other scale type. + for (const {type: t} of channels) { + if (t === undefined) continue; + else if (type === undefined) type = t; + else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`); + } + + // If the scale, a channel, or user specified a (consistent) type, return it. + if (type === typeProjection) return; + if (type !== undefined) return type; + + // If there’s no data (and no type) associated with this scale, don’t create a scale. + if (domain === undefined && !channels.some(({value}) => value !== undefined)) return; + + // Some scales have default types. + const kind = registry.get(key); + if (kind === radius) return "sqrt"; + if (kind === opacity || kind === length) return "linear"; + if (kind === symbol) return "ordinal"; + + // If the domain or range has more than two values, assume it’s ordinal. You + // can still use a “piecewise” (or “polylinear”) scale, but you must set the + // type explicitly. + if ((domain || range || []).length > 2) return asOrdinalType(kind); + + // Otherwise, infer the scale type from the data! Prefer the domain, if + // present, over channels. (The domain and channels should be consistently + // typed, and the domain is more explicit and typically much smaller.) We only + // check the first defined value for expedience and simplicity; we expect + // that the types are consistent. + if (domain !== undefined) { + if (isOrdinal(domain)) return asOrdinalType(kind); + if (isTemporal(domain)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; + } + + // If any channel is ordinal or temporal, it takes priority. + const values = channels.map(({value}) => value).filter((value) => value !== undefined); + if (values.some(isOrdinal)) return asOrdinalType(kind); + if (values.some(isTemporal)) return "utc"; + if (kind === color && (pivot != null || isDivergingScheme(scheme))) return "diverging"; + return "linear"; + } + + // Positional scales default to a point scale instead of an ordinal scale. + function asOrdinalType(kind) { + switch (kind) { + case position: + return "point"; + case color: + return ordinalImplicit; + default: + return "ordinal"; + } + } + + function isOrdinalScale({type}) { + return type === "ordinal" || type === "point" || type === "band" || type === ordinalImplicit; + } + + // Mutates channel.value! + function coerceType(channels, {domain, ...options}, coerceValues) { + for (const c of channels) { + if (c.value !== undefined) { + c.value = coerceValues(c.value); + } + } + return { + domain: domain === undefined ? domain : coerceValues(domain), + ...options + }; + } + + function coerceSymbols(values) { + return map(values, maybeSymbol); + } + + function scale(options = {}) { + let scale; + for (const key in options) { + if (!registry.has(key)) continue; // ignore unknown properties + if (!isScaleOptions(options[key])) continue; // e.g., ignore {color: "red"} + if (scale !== undefined) throw new Error("ambiguous scale definition; multiple scales found"); + scale = exposeScale(normalizeScale(key, options[key])); + } + if (scale === undefined) throw new Error("invalid scale definition; no scale found"); + return scale; + } + + // Note: axis- and legend-related properties (such as label, ticks and + // tickFormat) are not included here as they do not affect the scale’s behavior. + function exposeScale({scale, type, domain, range, interpolate, interval, transform, percent, pivot}) { + if (type === "identity") return {type: "identity", apply: (d) => d, invert: (d) => d}; + const unknown = scale.unknown ? scale.unknown() : undefined; + return { + type, + domain: slice(domain), // defensive copy + ...(range !== undefined && {range: slice(range)}), // defensive copy + ...(transform !== undefined && {transform}), + ...(percent && {percent}), // only exposed if truthy + ...(unknown !== undefined && {unknown}), + ...(interval !== undefined && {interval}), + + // quantitative + ...(interpolate !== undefined && {interpolate}), + ...(scale.clamp && {clamp: scale.clamp()}), + + // diverging (always asymmetric; we never want to apply the symmetric transform twice) + ...(pivot !== undefined && {pivot, symmetric: false}), + + // log, diverging-log + ...(scale.base && {base: scale.base()}), + + // pow, diverging-pow + ...(scale.exponent && {exponent: scale.exponent()}), + + // symlog, diverging-symlog + ...(scale.constant && {constant: scale.constant()}), + + // band, point + ...(scale.align && {align: scale.align(), round: scale.round()}), + ...(scale.padding && + (scale.paddingInner + ? {paddingInner: scale.paddingInner(), paddingOuter: scale.paddingOuter()} + : {padding: scale.padding()})), + ...(scale.bandwidth && {bandwidth: scale.bandwidth(), step: scale.step()}), + + // utilities + apply: (t) => scale(t), + ...(scale.invert && {invert: (t) => scale.invert(t)}) + }; + } + + var ScrollDirection; + (function (ScrollDirection) { + ScrollDirection[ScrollDirection["SCROLL_NONE"] = 0] = "SCROLL_NONE"; + ScrollDirection[ScrollDirection["SCROLL_BACKWARD"] = 1] = "SCROLL_BACKWARD"; + ScrollDirection[ScrollDirection["SCROLL_FORWARD"] = 2] = "SCROLL_FORWARD"; + })(ScrollDirection || (ScrollDirection = {})); + var Position; + (function (Position) { + Position[Position["TOP"] = 0] = "TOP"; + Position[Position["RIGHT"] = 1] = "RIGHT"; + Position[Position["BOTTOM"] = 2] = "BOTTOM"; + Position[Position["LEFT"] = 3] = "LEFT"; + })(Position || (Position = {})); + var OPTIONS_DEFAULT_SUBDOMAIN_WIDTH = 10; + var OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT = 10; + var OPTIONS_DEFAULT_SUBDOMAIN_GUTTER = 2; + var OPTIONS_DEFAULT_SUBDOMAIN_RADIUS = 0; + var SCALE_BASE_OPACITY_COLOR = 'red'; + + function normalizedScale(scaleOptions) { + try { + var scaleType = Object.keys(scaleOptions)[0]; + return scale(_defineProperty({}, scaleType, Object.assign(Object.assign({}, scaleOptions[scaleType]), { + clamp: true + }))); + } catch (error) { + return null; + } + } + function scaleStyle(_scale, scaleOptions) { + var styles = {}; + if (scaleOptions.hasOwnProperty('opacity')) { + styles.fill = function () { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + scaleOptions.opacity.baseColor || SCALE_BASE_OPACITY_COLOR + ); + }; + styles['fill-opacity'] = function (d) { + return _scale === null || _scale === void 0 ? void 0 : _scale.apply(d); + }; + } else { + styles.fill = function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + typeof d === 'string' && (d === null || d === void 0 ? void 0 : d.startsWith('#')) ? d : _scale === null || _scale === void 0 ? void 0 : _scale.apply(d) + ); + }; + } + return styles; + } + function applyScaleStyle(elem, _scale, scaleOptions, keyname) { + Object.entries(scaleStyle(_scale, scaleOptions)).forEach(function (_ref) { + var _ref2 = _slicedToArray(_ref, 2), + prop = _ref2[0], + val = _ref2[1]; + return ( + // eslint-disable-next-line implicit-arrow-linebreak + elem.style(prop, function (d) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + val(keyname ? d[keyname] : d) + ); + }) + ); + }); + } + + var $TypeError$1 = TypeError; + var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991 + + var doesNotExceedSafeInteger$1 = function (it) { + if (it > MAX_SAFE_INTEGER) throw $TypeError$1('Maximum allowed index exceeded'); + return it; + }; + + var $$7 = _export; + var fails$3 = fails$p; + var isArray = isArray$3; + var isObject = isObject$i; + var toObject$2 = toObject$8; + var lengthOfArrayLike$2 = lengthOfArrayLike$8; + var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1; + var createProperty$1 = createProperty$4; + var arraySpeciesCreate = arraySpeciesCreate$2; + var arrayMethodHasSpeciesSupport$2 = arrayMethodHasSpeciesSupport$4; + var wellKnownSymbol = wellKnownSymbol$k; + var V8_VERSION = engineV8Version; + + var IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable'); + + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/679 + var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails$3(function () { + var array = []; + array[IS_CONCAT_SPREADABLE] = false; + return array.concat()[0] !== array; + }); + + var isConcatSpreadable = function (O) { + if (!isObject(O)) return false; + var spreadable = O[IS_CONCAT_SPREADABLE]; + return spreadable !== undefined ? !!spreadable : isArray(O); + }; + + var FORCED$1 = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport$2('concat'); + + // `Array.prototype.concat` method + // https://tc39.es/ecma262/#sec-array.prototype.concat + // with adding support of @@isConcatSpreadable and @@species + $$7({ target: 'Array', proto: true, arity: 1, forced: FORCED$1 }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + concat: function concat(arg) { + var O = toObject$2(this); + var A = arraySpeciesCreate(O, 0); + var n = 0; + var i, k, length, len, E; + for (i = -1, length = arguments.length; i < length; i++) { + E = i === -1 ? O : arguments[i]; + if (isConcatSpreadable(E)) { + len = lengthOfArrayLike$2(E); + doesNotExceedSafeInteger(n + len); + for (k = 0; k < len; k++, n++) if (k in E) createProperty$1(A, n, E[k]); + } else { + doesNotExceedSafeInteger(n + 1); + createProperty$1(A, n++, E); + } + } + A.length = n; + return A; + } + }); + + var $$6 = _export; + var call$1 = functionCall; + var aCallable$1 = aCallable$a; + var newPromiseCapabilityModule = newPromiseCapability$2; + var perform = perform$4; + var iterate$1 = iterate$6; + var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration; + + // `Promise.allSettled` method + // https://tc39.es/ecma262/#sec-promise.allsettled + $$6({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + allSettled: function allSettled(iterable) { + var C = this; + var capability = newPromiseCapabilityModule.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform(function () { + var promiseResolve = aCallable$1(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$1(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$1(promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'fulfilled', value: value }; + --remaining || resolve(values); + }, function (error) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = { status: 'rejected', reason: error }; + --remaining || resolve(values); + }); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var create = objectCreate; + var defineBuiltInAccessor = defineBuiltInAccessor$3; + var defineBuiltIns = defineBuiltIns$2; + var bind$1 = functionBindContext; + var anInstance = anInstance$4; + var isNullOrUndefined = isNullOrUndefined$7; + var iterate = iterate$6; + var defineIterator = iteratorDefine; + var createIterResultObject = createIterResultObject$3; + var setSpecies = setSpecies$2; + var DESCRIPTORS = descriptors; + var fastKey = internalMetadataExports.fastKey; + var InternalStateModule = internalState; + + var setInternalState = InternalStateModule.set; + var internalStateGetterFor = InternalStateModule.getterFor; + + var collectionStrong$1 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + index: create(null), + first: undefined, + last: undefined, + size: 0 + }); + if (!DESCRIPTORS) that.size = 0; + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var entry = getEntry(that, key); + var previous, index; + // change existing entry + if (entry) { + entry.value = value; + // create new entry + } else { + state.last = entry = { + index: index = fastKey(key, true), + key: key, + value: value, + previous: previous = state.last, + next: undefined, + removed: false + }; + if (!state.first) state.first = entry; + if (previous) previous.next = entry; + if (DESCRIPTORS) state.size++; + else that.size++; + // add to index + if (index !== 'F') state.index[index] = entry; + } return that; + }; + + var getEntry = function (that, key) { + var state = getInternalState(that); + // fast case + var index = fastKey(key); + var entry; + if (index !== 'F') return state.index[index]; + // frozen object case + for (entry = state.first; entry; entry = entry.next) { + if (entry.key === key) return entry; + } + }; + + defineBuiltIns(Prototype, { + // `{ Map, Set }.prototype.clear()` methods + // https://tc39.es/ecma262/#sec-map.prototype.clear + // https://tc39.es/ecma262/#sec-set.prototype.clear + clear: function clear() { + var that = this; + var state = getInternalState(that); + var data = state.index; + var entry = state.first; + while (entry) { + entry.removed = true; + if (entry.previous) entry.previous = entry.previous.next = undefined; + delete data[entry.index]; + entry = entry.next; + } + state.first = state.last = undefined; + if (DESCRIPTORS) state.size = 0; + else that.size = 0; + }, + // `{ Map, Set }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.delete + // https://tc39.es/ecma262/#sec-set.prototype.delete + 'delete': function (key) { + var that = this; + var state = getInternalState(that); + var entry = getEntry(that, key); + if (entry) { + var next = entry.next; + var prev = entry.previous; + delete state.index[entry.index]; + entry.removed = true; + if (prev) prev.next = next; + if (next) next.previous = prev; + if (state.first === entry) state.first = next; + if (state.last === entry) state.last = prev; + if (DESCRIPTORS) state.size--; + else that.size--; + } return !!entry; + }, + // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods + // https://tc39.es/ecma262/#sec-map.prototype.foreach + // https://tc39.es/ecma262/#sec-set.prototype.foreach + forEach: function forEach(callbackfn /* , that = undefined */) { + var state = getInternalState(this); + var boundFunction = bind$1(callbackfn, arguments.length > 1 ? arguments[1] : undefined); + var entry; + while (entry = entry ? entry.next : state.first) { + boundFunction(entry.value, entry.key, this); + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + } + }, + // `{ Map, Set}.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-map.prototype.has + // https://tc39.es/ecma262/#sec-set.prototype.has + has: function has(key) { + return !!getEntry(this, key); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `Map.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-map.prototype.get + get: function get(key) { + var entry = getEntry(this, key); + return entry && entry.value; + }, + // `Map.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-map.prototype.set + set: function set(key, value) { + return define(this, key === 0 ? 0 : key, value); + } + } : { + // `Set.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-set.prototype.add + add: function add(value) { + return define(this, value = value === 0 ? 0 : value, value); + } + }); + if (DESCRIPTORS) defineBuiltInAccessor(Prototype, 'size', { + configurable: true, + get: function () { + return getInternalState(this).size; + } + }); + return Constructor; + }, + setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) { + var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator'; + var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME); + var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME); + // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods + // https://tc39.es/ecma262/#sec-map.prototype.entries + // https://tc39.es/ecma262/#sec-map.prototype.keys + // https://tc39.es/ecma262/#sec-map.prototype.values + // https://tc39.es/ecma262/#sec-map.prototype-@@iterator + // https://tc39.es/ecma262/#sec-set.prototype.entries + // https://tc39.es/ecma262/#sec-set.prototype.keys + // https://tc39.es/ecma262/#sec-set.prototype.values + // https://tc39.es/ecma262/#sec-set.prototype-@@iterator + defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) { + setInternalState(this, { + type: ITERATOR_NAME, + target: iterated, + state: getInternalCollectionState(iterated), + kind: kind, + last: undefined + }); + }, function () { + var state = getInternalIteratorState(this); + var kind = state.kind; + var entry = state.last; + // revert to the last existing entry + while (entry && entry.removed) entry = entry.previous; + // get next entry + if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) { + // or finish the iteration + state.target = undefined; + return createIterResultObject(undefined, true); + } + // return step by kind + if (kind === 'keys') return createIterResultObject(entry.key, false); + if (kind === 'values') return createIterResultObject(entry.value, false); + return createIterResultObject([entry.key, entry.value], false); + }, IS_MAP ? 'entries' : 'values', !IS_MAP, true); + + // `{ Map, Set }.prototype[@@species]` accessors + // https://tc39.es/ecma262/#sec-get-map-@@species + // https://tc39.es/ecma262/#sec-get-set-@@species + setSpecies(CONSTRUCTOR_NAME); + } + }; + + var collection = collection$2; + var collectionStrong = collectionStrong$1; + + // `Map` constructor + // https://tc39.es/ecma262/#sec-map-objects + collection('Map', function (init) { + return function Map() { return init(this, arguments.length ? arguments[0] : undefined); }; + }, collectionStrong); + + var tryToString = tryToString$5; + + var $TypeError = TypeError; + + var deletePropertyOrThrow$1 = function (O, P) { + if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O)); + }; + + var arraySlice = arraySliceSimple; + + var floor = Math.floor; + + var mergeSort = function (array, comparefn) { + var length = array.length; + var middle = floor(length / 2); + return length < 8 ? insertionSort(array, comparefn) : merge( + array, + mergeSort(arraySlice(array, 0, middle), comparefn), + mergeSort(arraySlice(array, middle), comparefn), + comparefn + ); + }; + + var insertionSort = function (array, comparefn) { + var length = array.length; + var i = 1; + var element, j; + + while (i < length) { + j = i; + element = array[i]; + while (j && comparefn(array[j - 1], element) > 0) { + array[j] = array[--j]; + } + if (j !== i++) array[j] = element; + } return array; + }; + + var merge = function (array, left, right, comparefn) { + var llength = left.length; + var rlength = right.length; + var lindex = 0; + var rindex = 0; + + while (lindex < llength || rindex < rlength) { + array[lindex + rindex] = (lindex < llength && rindex < rlength) + ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++] + : lindex < llength ? left[lindex++] : right[rindex++]; + } return array; + }; + + var arraySort = mergeSort; + + var userAgent$1 = engineUserAgent; + + var firefox = userAgent$1.match(/firefox\/(\d+)/i); + + var engineFfVersion = !!firefox && +firefox[1]; + + var UA = engineUserAgent; + + var engineIsIeOrEdge = /MSIE|Trident/.test(UA); + + var userAgent = engineUserAgent; + + var webkit = userAgent.match(/AppleWebKit\/(\d+)\./); + + var engineWebkitVersion = !!webkit && +webkit[1]; + + var $$5 = _export; + var uncurryThis$1 = functionUncurryThis; + var aCallable = aCallable$a; + var toObject$1 = toObject$8; + var lengthOfArrayLike$1 = lengthOfArrayLike$8; + var deletePropertyOrThrow = deletePropertyOrThrow$1; + var toString$1 = toString$5; + var fails$2 = fails$p; + var internalSort = arraySort; + var arrayMethodIsStrict = arrayMethodIsStrict$3; + var FF = engineFfVersion; + var IE_OR_EDGE = engineIsIeOrEdge; + var V8 = engineV8Version; + var WEBKIT = engineWebkitVersion; + + var test = []; + var nativeSort = uncurryThis$1(test.sort); + var push = uncurryThis$1(test.push); + + // IE8- + var FAILS_ON_UNDEFINED = fails$2(function () { + test.sort(undefined); + }); + // V8 bug + var FAILS_ON_NULL = fails$2(function () { + test.sort(null); + }); + // Old WebKit + var STRICT_METHOD = arrayMethodIsStrict('sort'); + + var STABLE_SORT = !fails$2(function () { + // feature detection can be too slow, so check engines versions + if (V8) return V8 < 70; + if (FF && FF > 3) return; + if (IE_OR_EDGE) return true; + if (WEBKIT) return WEBKIT < 603; + + var result = ''; + var code, chr, value, index; + + // generate an array with more 512 elements (Chakra and old V8 fails only in this case) + for (code = 65; code < 76; code++) { + chr = String.fromCharCode(code); + + switch (code) { + case 66: case 69: case 70: case 72: value = 3; break; + case 68: case 71: value = 4; break; + default: value = 2; + } + + for (index = 0; index < 47; index++) { + test.push({ k: chr + index, v: value }); + } + } + + test.sort(function (a, b) { return b.v - a.v; }); + + for (index = 0; index < test.length; index++) { + chr = test[index].k.charAt(0); + if (result.charAt(result.length - 1) !== chr) result += chr; + } + + return result !== 'DGBEFHACIJK'; + }); + + var FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT; + + var getSortCompare = function (comparefn) { + return function (x, y) { + if (y === undefined) return -1; + if (x === undefined) return 1; + if (comparefn !== undefined) return +comparefn(x, y) || 0; + return toString$1(x) > toString$1(y) ? 1 : -1; + }; + }; + + // `Array.prototype.sort` method + // https://tc39.es/ecma262/#sec-array.prototype.sort + $$5({ target: 'Array', proto: true, forced: FORCED }, { + sort: function sort(comparefn) { + if (comparefn !== undefined) aCallable(comparefn); + + var array = toObject$1(this); + + if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn); + + var items = []; + var arrayLength = lengthOfArrayLike$1(array); + var itemsLength, index; + + for (index = 0; index < arrayLength; index++) { + if (index in array) push(items, array[index]); + } + + internalSort(items, getSortCompare(comparefn)); + + itemsLength = lengthOfArrayLike$1(items); + index = 0; + + while (index < itemsLength) array[index] = items[index++]; + while (index < arrayLength) deletePropertyOrThrow(array, index++); + + return array; + } + }); + + var $$4 = _export; + var $includes = arrayIncludes.includes; + var fails$1 = fails$p; + var addToUnscopables = addToUnscopables$2; + + // FF99+ bug + var BROKEN_ON_SPARSE = fails$1(function () { + // eslint-disable-next-line es/no-array-prototype-includes -- detection + return !Array(1).includes(); + }); + + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + $$4({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, { + includes: function includes(el /* , fromIndex = 0 */) { + return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined); + } + }); + + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + addToUnscopables('includes'); + + var $$3 = _export; + var $map = arrayIteration.map; + var arrayMethodHasSpeciesSupport$1 = arrayMethodHasSpeciesSupport$4; + + var HAS_SPECIES_SUPPORT$1 = arrayMethodHasSpeciesSupport$1('map'); + + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + // with adding support of @@species + $$3({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT$1 }, { + map: function map(callbackfn /* , thisArg */) { + return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } + }); + + var $$2 = _export; + var $filter = arrayIteration.filter; + var arrayMethodHasSpeciesSupport = arrayMethodHasSpeciesSupport$4; + + var HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter'); + + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + // with adding support of @@species + $$2({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, { + filter: function filter(callbackfn /* , thisArg */) { + return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined); + } + }); + + var anObject = anObject$c; + var iteratorClose = iteratorClose$2; + + // call something on iterator step with safe closing on error + var callWithSafeIterationClosing$1 = function (iterator, fn, value, ENTRIES) { + try { + return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + }; + + var bind = functionBindContext; + var call = functionCall; + var toObject = toObject$8; + var callWithSafeIterationClosing = callWithSafeIterationClosing$1; + var isArrayIteratorMethod = isArrayIteratorMethod$2; + var isConstructor = isConstructor$4; + var lengthOfArrayLike = lengthOfArrayLike$8; + var createProperty = createProperty$4; + var getIterator = getIterator$2; + var getIteratorMethod = getIteratorMethod$3; + + var $Array = Array; + + // `Array.from` method implementation + // https://tc39.es/ecma262/#sec-array.from + var arrayFrom = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) { + var O = toObject(arrayLike); + var IS_CONSTRUCTOR = isConstructor(this); + var argumentsLength = arguments.length; + var mapfn = argumentsLength > 1 ? arguments[1] : undefined; + var mapping = mapfn !== undefined; + if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined); + var iteratorMethod = getIteratorMethod(O); + var index = 0; + var length, result, step, iterator, next, value; + // if the target is not iterable or it's an array with the default iterator - use a simple case + if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) { + iterator = getIterator(O, iteratorMethod); + next = iterator.next; + result = IS_CONSTRUCTOR ? new this() : []; + for (;!(step = call(next, iterator)).done; index++) { + value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value; + createProperty(result, index, value); + } + } else { + length = lengthOfArrayLike(O); + result = IS_CONSTRUCTOR ? new this(length) : $Array(length); + for (;length > index; index++) { + value = mapping ? mapfn(O[index], index) : O[index]; + createProperty(result, index, value); + } + } + result.length = index; + return result; + }; + + var $$1 = _export; + var from = arrayFrom; + var checkCorrectnessOfIteration = checkCorrectnessOfIteration$3; + + var INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) { + // eslint-disable-next-line es/no-array-from -- required for testing + Array.from(iterable); + }); + + // `Array.from` method + // https://tc39.es/ecma262/#sec-array.from + $$1({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, { + from: from + }); + + // a string of all valid unicode whitespaces + var whitespaces$2 = '\u0009\u000A\u000B\u000C\u000D\u0020\u00A0\u1680\u2000\u2001\u2002' + + '\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF'; + + var uncurryThis = functionUncurryThis; + var requireObjectCoercible = requireObjectCoercible$5; + var toString = toString$5; + var whitespaces$1 = whitespaces$2; + + var replace = uncurryThis(''.replace); + var ltrim = RegExp('^[' + whitespaces$1 + ']+'); + var rtrim = RegExp('(^|[^' + whitespaces$1 + '])[' + whitespaces$1 + ']+$'); + + // `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation + var createMethod = function (TYPE) { + return function ($this) { + var string = toString(requireObjectCoercible($this)); + if (TYPE & 1) string = replace(string, ltrim, ''); + if (TYPE & 2) string = replace(string, rtrim, '$1'); + return string; + }; + }; + + var stringTrim = { + // `String.prototype.{ trimLeft, trimStart }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimstart + start: createMethod(1), + // `String.prototype.{ trimRight, trimEnd }` methods + // https://tc39.es/ecma262/#sec-string.prototype.trimend + end: createMethod(2), + // `String.prototype.trim` method + // https://tc39.es/ecma262/#sec-string.prototype.trim + trim: createMethod(3) + }; + + var PROPER_FUNCTION_NAME = functionName.PROPER; + var fails = fails$p; + var whitespaces = whitespaces$2; + + var non = '\u200B\u0085\u180E'; + + // check that a method works with the correct list + // of whitespaces and has a correct name + var stringTrimForced = function (METHOD_NAME) { + return fails(function () { + return !!whitespaces[METHOD_NAME]() + || non[METHOD_NAME]() !== non + || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME); + }); + }; + + var $ = _export; + var $trim = stringTrim.trim; + var forcedStringTrimMethod = stringTrimForced; + + // `String.prototype.trim` method + // https://tc39.es/ecma262/#sec-string.prototype.trim + $({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, { + trim: function trim() { + return $trim(this); + } + }); + + var DEFAULT_SELECTOR$2 = '.ch-subdomain'; + + var DEFAULT_SELECTOR$1 = '.ch-container'; + + var _LegendLite_instances, _LegendLite_buildLegend, _LegendLite_nodeAttrs; + var DEFAULT_SELECTOR = '.ch-plugin-legend-lite'; + var defaultOptions = { + enabled: true, + // Whether to display the legend + itemSelector: null, + width: OPTIONS_DEFAULT_SUBDOMAIN_WIDTH, + height: OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT, + gutter: OPTIONS_DEFAULT_SUBDOMAIN_GUTTER, + radius: OPTIONS_DEFAULT_SUBDOMAIN_RADIUS, + includeBlank: false + }; + var LegendLite = /*#__PURE__*/function () { + function LegendLite(calendar) { + _classCallCheck(this, LegendLite); + _LegendLite_instances.add(this); + this.name = 'LegendLite'; + this.calendar = calendar; + this.root = null; + this.shown = false; + this.options = defaultOptions; + } + _createClass(LegendLite, [{ + key: "setup", + value: function setup(pluginOptions) { + this.options = Object.assign(Object.assign({}, this.options), pluginOptions); + } + }, { + key: "paint", + value: function paint() { + var _this$options = this.options, + enabled = _this$options.enabled, + itemSelector = _this$options.itemSelector; + if (!enabled || itemSelector && d3Selection.select(itemSelector).empty()) { + return this.destroy(); + } + this.shown = true; + this.root = d3Selection.select(itemSelector || this.calendar.options.options.itemSelector); + if (this.root.select(DEFAULT_SELECTOR).empty()) { + this.root = this.root.append('div').attr('class', DEFAULT_SELECTOR.slice(1)); + } else { + this.root = this.root.select(DEFAULT_SELECTOR); + } + var node = __classPrivateFieldGet(this, _LegendLite_instances, "m", _LegendLite_buildLegend).call(this); + this.root.selectAll('*').remove(); + this.root.append(function () { + return node.node(); + }); + return Promise.resolve(); + } + }, { + key: "destroy", + value: function destroy() { + if (this.root !== null) { + this.root.remove(); + this.root = null; + } + return Promise.resolve(); + } + }]); + return LegendLite; + }(); + _LegendLite_instances = new WeakSet(), _LegendLite_buildLegend = function _LegendLite_buildLegend() { + var _this = this; + var node = d3Selection.create('svg'); + var scale = normalizedScale(this.calendar.options.options.scale); + var _this$options2 = this.options, + width = _this$options2.width, + height = _this$options2.height, + gutter = _this$options2.gutter, + includeBlank = _this$options2.includeBlank; + var localRange = _toConsumableArray(scale.range); + if (includeBlank) { + localRange.unshift(null); + } + node.attr('class', DEFAULT_SELECTOR$1.slice(1)).attr('width', localRange.length * width + (localRange.length - 1) * gutter).attr('height', height); + node.selectAll('rect').data(localRange).join(function (enter) { + return enter.append('rect').call(function (sc) { + return ( + // eslint-disable-next-line implicit-arrow-linebreak + __classPrivateFieldGet(_this, _LegendLite_instances, "m", _LegendLite_nodeAttrs).call(_this, sc, scale) + ); + }); + }, function (update) { + return update.selectAll('rect').call(function (sc) { + return __classPrivateFieldGet(_this, _LegendLite_instances, "m", _LegendLite_nodeAttrs).call(_this, sc, scale); + }); + }); + return node; + }, _LegendLite_nodeAttrs = function _LegendLite_nodeAttrs(selection, scale) { + var _this2 = this; + var _this$options3 = this.options, + width = _this$options3.width, + height = _this$options3.height, + radius = _this$options3.radius, + gutter = _this$options3.gutter; + return selection.attr('width', width).attr('height', height).attr('class', "".concat(DEFAULT_SELECTOR$2.slice(1), "-bg")).attr('rx', radius).attr('ry', radius).attr('x', function (_d, i) { + return i * (width + gutter); + }).attr('y', 0).call(function (element) { + applyScaleStyle(element, scale, _this2.calendar.options.options.scale); + }); + }; + + return LegendLite; + +})); diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.esm.js b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.esm.js new file mode 100644 index 0000000..567ef48 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.esm.js @@ -0,0 +1 @@ +import{select as t,create as n}from"d3-selection";import{ascending as e,timeSecond as r,timeMinute as o,timeHour as i,timeDay as a,timeWeek as u,timeMonth as c,timeYear as s,timeMonday as f,timeTuesday as l,timeWednesday as d,timeThursday as p,timeFriday as h,timeSaturday as v,timeSunday as y,utcSecond as g,utcMinute as m,utcHour as b,utcDay as w,utcWeek as S,utcMonth as O,utcYear as j,utcMonday as E,utcTuesday as T,utcWednesday as x,utcThursday as A,utcFriday as M,utcSaturday as k,utcSunday as P,descending as I,range as C,symbolAsterisk as R,symbolCircle as L,symbolCross as N,symbolDiamond as D,symbolDiamond2 as F,symbolPlus as _,symbolSquare as $,symbolSquare2 as q,symbolStar as z,symbolTimes as W,symbolTriangle as G,symbolTriangle2 as B,symbolWye as U,schemeAccent as H,schemeCategory10 as V,schemeDark2 as K,schemePaired as Y,schemePastel1 as J,schemePastel2 as X,schemeSet1 as Z,schemeSet2 as Q,schemeSet3 as tt,schemeTableau10 as nt,quantize as et,interpolateBrBG as rt,interpolatePRGn as ot,interpolatePiYG as it,interpolatePuOr as at,interpolateRdBu as ut,interpolateRdGy as ct,interpolateRdYlBu as st,interpolateRdYlGn as ft,interpolateSpectral as lt,interpolateBlues as dt,interpolateGreens as pt,interpolateGreys as ht,interpolatePurples as vt,interpolateReds as yt,interpolateOranges as gt,interpolateTurbo as mt,interpolateViridis as bt,interpolateMagma as wt,interpolateInferno as St,interpolatePlasma as Ot,interpolateCividis as jt,interpolateCubehelixDefault as Et,interpolateWarm as Tt,interpolateCool as xt,interpolateBuGn as At,interpolateBuPu as Mt,interpolateGnBu as kt,interpolateOrRd as Pt,interpolatePuBuGn as It,interpolatePuBu as Ct,interpolatePuRd as Rt,interpolateRdPu as Lt,interpolateYlGnBu as Nt,interpolateYlGn as Dt,interpolateYlOrBr as Ft,interpolateYlOrRd as _t,interpolateRainbow as $t,interpolateSinebow as qt,schemeBrBG as zt,schemePRGn as Wt,schemePiYG as Gt,schemePuOr as Bt,schemeRdBu as Ut,schemeRdGy as Ht,schemeRdYlBu as Vt,schemeRdYlGn as Kt,schemeSpectral as Yt,schemeBlues as Jt,schemeGreens as Xt,schemeGreys as Zt,schemeOranges as Qt,schemePurples as tn,schemeReds as nn,schemeBuGn as en,schemeBuPu as rn,schemeGnBu as on,schemeOrRd as an,schemePuBu as un,schemePuBuGn as cn,schemePuRd as sn,schemeRdPu as fn,schemeYlGn as ln,schemeYlGnBu as dn,schemeYlOrBr as pn,schemeYlOrRd as hn,scaleLinear as vn,scalePow as yn,scaleLog as gn,scaleSymlog as mn,scaleQuantile as bn,extent as wn,ticks as Sn,interpolateNumber as On,reverse as jn,scaleThreshold as En,scaleIdentity as Tn,max as xn,interpolateRgb as An,interpolateRound as Mn,min as kn,quantile as Pn,median as In,interpolateHsl as Cn,interpolateHcl as Rn,interpolateLab as Ln,scaleDiverging as Nn,scaleDivergingPow as Dn,scaleDivergingLog as Fn,scaleDivergingSymlog as _n,piecewise as $n,scaleTime as qn,scaleUtc as zn,scaleImplicit as Wn,scaleOrdinal as Gn,scalePoint as Bn,scaleBand as Un,InternSet as Hn,sort as Vn,symbolsStroke as Kn,symbolsFill as Yn}from"d3";function Jn(t,n){for(var e=0;et.length)&&(n=t.length);for(var e=0,r=new Array(n);e0&&Ge[0]<4?1:+(Ge[0]+Ge[1])),!Be&&br&&(!(Ge=br.match(/Edge\/(\d+)/))||Ge[1]>=74)&&(Ge=br.match(/Chrome\/(\d+)/))&&(Be=+Ge[1]);var Er=Be,Tr=Er,xr=re,Ar=Re.String,Mr=!!Object.getOwnPropertySymbols&&!xr((function(){var t=Symbol("symbol detection");return!Ar(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&Tr&&Tr<41})),kr=Mr&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,Pr=vr,Ir=Ie,Cr=yr,Rr=Object,Lr=kr?function(t){return"symbol"==typeof t}:function(t){var n=Pr("Symbol");return Ir(n)&&Cr(n.prototype,Rr(t))},Nr=String,Dr=function(t){try{return Nr(t)}catch(t){return"Object"}},Fr=Ie,_r=Dr,$r=TypeError,qr=function(t){if(Fr(t))return t;throw new $r(_r(t)+" is not a function")},zr=qr,Wr=le,Gr=function(t,n){var e=t[n];return Wr(e)?void 0:zr(e)},Br=dr,Ur=Ie,Hr=Xe,Vr=TypeError,Kr={exports:{}},Yr=$e;(Kr.exports=function(t,n){return Yr[t]||(Yr[t]=void 0!==n?n:{})})("versions",[]).push({version:"3.34.0",mode:"global",copyright:"© 2014-2023 Denis Pushkarev (zloirock.ru)",license:"https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE",source:"https://github.com/zloirock/core-js"});var Jr=Kr.exports,Xr=fe,Zr=0,Qr=Math.random(),to=Xr(1..toString),no=function(t){return"Symbol("+(void 0===t?"":t)+")_"+to(++Zr+Qr,36)},eo=Jr,ro=we,oo=no,io=Mr,ao=kr,uo=Re.Symbol,co=eo("wks"),so=ao?uo.for||uo:uo&&uo.withoutSetter||oo,fo=function(t){return ro(co,t)||(co[t]=io&&ro(uo,t)?uo[t]:so("Symbol."+t)),co[t]},lo=dr,po=Xe,ho=Lr,vo=Gr,yo=function(t,n){var e,r;if("string"===n&&Ur(e=t.toString)&&!Hr(r=Br(e,t)))return r;if(Ur(e=t.valueOf)&&!Hr(r=Br(e,t)))return r;if("string"!==n&&Ur(e=t.toString)&&!Hr(r=Br(e,t)))return r;throw new Vr("Can't convert object to primitive value")},go=TypeError,mo=fo("toPrimitive"),bo=function(t,n){if(!po(t)||ho(t))return t;var e,r=vo(t,mo);if(r){if(void 0===n&&(n="default"),e=lo(r,t,n),!po(e)||ho(e))return e;throw new go("Can't convert object to primitive value")}return void 0===n&&(n="number"),yo(t,n)},wo=Lr,So=function(t){var n=bo(t,"string");return wo(n)?n:n+""},Oo=oe,jo=or,Eo=ir,To=sr,xo=So,Ao=TypeError,Mo=Object.defineProperty,ko=Object.getOwnPropertyDescriptor,Po="enumerable",Io="configurable",Co="writable";Ze.f=Oo?Eo?function(t,n,e){if(To(t),n=xo(n),To(e),"function"==typeof t&&"prototype"===n&&"value"in e&&Co in e&&!e[Co]){var r=ko(t,n);r&&r[Co]&&(t[n]=e.value,e={configurable:Io in e?e[Io]:r[Io],enumerable:Po in e?e[Po]:r[Po],writable:!1})}return Mo(t,n,e)}:Mo:function(t,n,e){if(To(t),n=xo(n),To(e),jo)try{return Mo(t,n,e)}catch(t){}if("get"in e||"set"in e)throw new Ao("Accessors not supported");return"value"in e&&(t[n]=e.value),t};var Ro,Lo,No,Do=function(t,n){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:n}},Fo=Ze,_o=Do,$o=oe?function(t,n,e){return Fo.f(t,n,_o(1,e))}:function(t,n,e){return t[n]=e,t},qo=no,zo=Jr("keys"),Wo=function(t){return zo[t]||(zo[t]=qo(t))},Go={},Bo=Ke,Uo=Re,Ho=Xe,Vo=$o,Ko=we,Yo=$e,Jo=Wo,Xo=Go,Zo="Object already initialized",Qo=Uo.TypeError,ti=Uo.WeakMap;if(Bo||Yo.state){var ni=Yo.state||(Yo.state=new ti);ni.get=ni.get,ni.has=ni.has,ni.set=ni.set,Ro=function(t,n){if(ni.has(t))throw new Qo(Zo);return n.facade=t,ni.set(t,n),n},Lo=function(t){return ni.get(t)||{}},No=function(t){return ni.has(t)}}else{var ei=Jo("state");Xo[ei]=!0,Ro=function(t,n){if(Ko(t,ei))throw new Qo(Zo);return n.facade=t,Vo(t,ei,n),n},Lo=function(t){return Ko(t,ei)?t[ei]:{}},No=function(t){return Ko(t,ei)}}var ri={set:Ro,get:Lo,has:No,enforce:function(t){return No(t)?Lo(t):Ro(t,{})},getterFor:function(t){return function(n){var e;if(!Ho(n)||(e=Lo(n)).type!==t)throw new Qo("Incompatible receiver, "+t+" required");return e}}},oi=fe,ii=re,ai=Ie,ui=we,ci=oe,si=xe.CONFIGURABLE,fi=Ue,li=ri.enforce,di=ri.get,pi=String,hi=Object.defineProperty,vi=oi("".slice),yi=oi("".replace),gi=oi([].join),mi=ci&&!ii((function(){return 8!==hi((function(){}),"length",{value:8}).length})),bi=String(String).split("String"),wi=Ae.exports=function(t,n,e){"Symbol("===vi(pi(n),0,7)&&(n="["+yi(pi(n),/^Symbol\(([^)]*)\)/,"$1")+"]"),e&&e.getter&&(n="get "+n),e&&e.setter&&(n="set "+n),(!ui(t,"name")||si&&t.name!==n)&&(ci?hi(t,"name",{value:n,configurable:!0}):t.name=n),mi&&e&&ui(e,"arity")&&t.length!==e.arity&&hi(t,"length",{value:e.arity});try{e&&ui(e,"constructor")&&e.constructor?ci&&hi(t,"prototype",{writable:!1}):t.prototype&&(t.prototype=void 0)}catch(t){}var r=li(t);return ui(r,"source")||(r.source=gi(bi,"string"==typeof n?n:"")),t};Function.prototype.toString=wi((function(){return ai(this)&&di(this).source||fi(this)}),"toString");var Si=Ae.exports,Oi=Si,ji=Ze,Ei=function(t,n,e){return e.get&&Oi(e.get,n,{getter:!0}),e.set&&Oi(e.set,n,{setter:!0}),ji.f(t,n,e)},Ti=oe,xi=xe.EXISTS,Ai=fe,Mi=Ei,ki=Function.prototype,Pi=Ai(ki.toString),Ii=/function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/,Ci=Ai(Ii.exec);Ti&&!xi&&Mi(ki,"name",{configurable:!0,get:function(){try{return Ci(Ii,Pi(this))[1]}catch(t){return""}}});var Ri={},Li={},Ni={}.propertyIsEnumerable,Di=Object.getOwnPropertyDescriptor,Fi=Di&&!Ni.call({1:2},1);Li.f=Fi?function(t){var n=Di(this,t);return!!n&&n.enumerable}:Ni;var _i=fe,$i=_i({}.toString),qi=_i("".slice),zi=function(t){return qi($i(t),8,-1)},Wi=re,Gi=zi,Bi=Object,Ui=fe("".split),Hi=Wi((function(){return!Bi("z").propertyIsEnumerable(0)}))?function(t){return"String"===Gi(t)?Ui(t,""):Bi(t)}:Bi,Vi=Hi,Ki=he,Yi=function(t){return Vi(Ki(t))},Ji=oe,Xi=dr,Zi=Li,Qi=Do,ta=Yi,na=So,ea=we,ra=or,oa=Object.getOwnPropertyDescriptor;Ri.f=Ji?oa:function(t,n){if(t=ta(t),n=na(n),ra)try{return oa(t,n)}catch(t){}if(ea(t,n))return Qi(!Xi(Zi.f,t,n),t[n])};var ia=Ie,aa=Ze,ua=Si,ca=De,sa=function(t,n,e,r){r||(r={});var o=r.enumerable,i=void 0!==r.name?r.name:n;if(ia(e)&&ua(e,i,r),r.global)o?t[n]=e:ca(n,e);else{try{r.unsafe?t[n]&&(o=!0):delete t[n]}catch(t){}o?t[n]=e:aa.f(t,n,{value:e,enumerable:!1,configurable:!r.nonConfigurable,writable:!r.nonWritable})}return t},fa={},la=Math.ceil,da=Math.floor,pa=Math.trunc||function(t){var n=+t;return(n>0?da:la)(n)},ha=function(t){var n=+t;return n!=n||0===n?0:pa(n)},va=ha,ya=Math.max,ga=Math.min,ma=function(t,n){var e=va(t);return e<0?ya(e+n,0):ga(e,n)},ba=ha,wa=Math.min,Sa=function(t){return t>0?wa(ba(t),9007199254740991):0},Oa=Sa,ja=function(t){return Oa(t.length)},Ea=Yi,Ta=ma,xa=ja,Aa=function(t){return function(n,e,r){var o,i=Ea(n),a=xa(i),u=Ta(r,a);if(t&&e!=e){for(;a>u;)if((o=i[u++])!=o)return!0}else for(;a>u;u++)if((t||u in i)&&i[u]===e)return t||u||0;return!t&&-1}},Ma={includes:Aa(!0),indexOf:Aa(!1)},ka=we,Pa=Yi,Ia=Ma.indexOf,Ca=Go,Ra=fe([].push),La=function(t,n){var e,r=Pa(t),o=0,i=[];for(e in r)!ka(Ca,e)&&ka(r,e)&&Ra(i,e);for(;n.length>o;)ka(r,e=n[o++])&&(~Ia(i,e)||Ra(i,e));return i},Na=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],Da=La,Fa=Na.concat("length","prototype");fa.f=Object.getOwnPropertyNames||function(t){return Da(t,Fa)};var _a={};_a.f=Object.getOwnPropertySymbols;var $a=vr,qa=fa,za=_a,Wa=sr,Ga=fe([].concat),Ba=$a("Reflect","ownKeys")||function(t){var n=qa.f(Wa(t)),e=za.f;return e?Ga(n,e(t)):n},Ua=we,Ha=Ba,Va=Ri,Ka=Ze,Ya=re,Ja=Ie,Xa=/#|\.prototype\./,Za=function(t,n){var e=tu[Qa(t)];return e===eu||e!==nu&&(Ja(n)?Ya(n):!!n)},Qa=Za.normalize=function(t){return String(t).replace(Xa,".").toLowerCase()},tu=Za.data={},nu=Za.NATIVE="N",eu=Za.POLYFILL="P",ru=Za,ou=Re,iu=Ri.f,au=$o,uu=sa,cu=De,su=function(t,n,e){for(var r=Ha(n),o=Ka.f,i=Va.f,a=0;ao;)for(var u,c=ju(arguments[o++]),s=i?xu(bu(c),i(c)):bu(c),f=s.length,l=0;f>l;)u=s[l++],vu&&!gu(a,c,u)||(e[u]=c[u]);return e}:Eu,Mu=Au;lu({target:"Object",stat:!0,arity:2,forced:Object.assign!==Mu},{assign:Mu});var ku={};ku[fo("toStringTag")]="z";var Pu="[object z]"===String(ku),Iu=Pu,Cu=Ie,Ru=zi,Lu=fo("toStringTag"),Nu=Object,Du="Arguments"===Ru(function(){return arguments}()),Fu=Iu?Ru:function(t){var n,e,r;return void 0===t?"Undefined":null===t?"Null":"string"==typeof(e=function(t,n){try{return t[n]}catch(t){}}(n=Nu(t),Lu))?e:Du?Ru(n):"Object"===(r=Ru(n))&&Cu(n.callee)?"Arguments":r},_u=Fu,$u=Pu?{}.toString:function(){return"[object "+_u(this)+"]"};Pu||sa(Object.prototype,"toString",$u,{unsafe:!0});var qu="process"===zi(Re.process),zu=fe,Wu=qr,Gu=Ie,Bu=String,Uu=TypeError,Hu=function(t,n,e){try{return zu(Wu(Object.getOwnPropertyDescriptor(t,n)[e]))}catch(t){}},Vu=sr,Ku=function(t){if("object"==typeof t||Gu(t))return t;throw new Uu("Can't set "+Bu(t)+" as a prototype")},Yu=Object.setPrototypeOf||("__proto__"in{}?function(){var t,n=!1,e={};try{(t=Hu(Object.prototype,"__proto__","set"))(e,[]),n=e instanceof Array}catch(t){}return function(e,r){return Vu(e),Ku(r),n?t(e,r):e.__proto__=r,e}}():void 0),Ju=Ze.f,Xu=we,Zu=fo("toStringTag"),Qu=function(t,n,e){t&&!e&&(t=t.prototype),t&&!Xu(t,Zu)&&Ju(t,Zu,{configurable:!0,value:n})},tc=vr,nc=Ei,ec=oe,rc=fo("species"),oc=function(t){var n=tc(t);ec&&n&&!n[rc]&&nc(n,rc,{configurable:!0,get:function(){return this}})},ic=yr,ac=TypeError,uc=function(t,n){if(ic(n,t))return t;throw new ac("Incorrect invocation")},cc=fe,sc=re,fc=Ie,lc=Fu,dc=Ue,pc=function(){},hc=[],vc=vr("Reflect","construct"),yc=/^\s*(?:class|function)\b/,gc=cc(yc.exec),mc=!yc.test(pc),bc=function(t){if(!fc(t))return!1;try{return vc(pc,hc,t),!0}catch(t){return!1}},wc=function(t){if(!fc(t))return!1;switch(lc(t)){case"AsyncFunction":case"GeneratorFunction":case"AsyncGeneratorFunction":return!1}try{return mc||!!gc(yc,dc(t))}catch(t){return!0}};wc.sham=!0;var Sc,Oc,jc,Ec,Tc=!vc||sc((function(){var t;return bc(bc.call)||!bc(Object)||!bc((function(){t=!0}))||t}))?wc:bc,xc=Tc,Ac=Dr,Mc=TypeError,kc=sr,Pc=function(t){if(xc(t))return t;throw new Mc(Ac(t)+" is not a constructor")},Ic=le,Cc=fo("species"),Rc=ie,Lc=Function.prototype,Nc=Lc.apply,Dc=Lc.call,Fc="object"==typeof Reflect&&Reflect.apply||(Rc?Dc.bind(Nc):function(){return Dc.apply(Nc,arguments)}),_c=zi,$c=fe,qc=function(t){if("Function"===_c(t))return $c(t)},zc=qr,Wc=ie,Gc=qc(qc.bind),Bc=function(t,n){return zc(t),void 0===n?t:Wc?Gc(t,n):function(){return t.apply(n,arguments)}},Uc=vr("document","documentElement"),Hc=fe([].slice),Vc=TypeError,Kc=/(?:ipad|iphone|ipod).*applewebkit/i.test(gr),Yc=Re,Jc=Fc,Xc=Bc,Zc=Ie,Qc=we,ts=re,ns=Uc,es=Hc,rs=er,os=function(t,n){if(ti;i++)if((u=g(t[i]))&&Wl(Kl,u))return u;return new Vl(!1)}r=Gl(t,o)}for(c=d?t.next:r.next;!(s=Fl(c,r)).done;){try{u=g(s.value)}catch(t){Ul(r,"throw",t)}if("object"==typeof u&&u&&Wl(Kl,u))return u}return new Vl(!1)},Jl=fo("iterator"),Xl=!1;try{var Zl=0,Ql={next:function(){return{done:!!Zl++}},return:function(){Xl=!0}};Ql[Jl]=function(){return this},Array.from(Ql,(function(){throw 2}))}catch(t){}var td=function(t,n){try{if(!n&&!Xl)return!1}catch(t){return!1}var e=!1;try{var r={};r[Jl]=function(){return{next:function(){return{done:e=!0}}}},t(r)}catch(t){}return e},nd=Js,ed=pf.CONSTRUCTOR||!td((function(t){nd.all(t).then(void 0,(function(){}))})),rd=dr,od=qr,id=hf,ad=Ys,ud=Yl;lu({target:"Promise",stat:!0,forced:ed},{all:function(t){var n=this,e=id.f(n),r=e.resolve,o=e.reject,i=ad((function(){var e=od(n.resolve),i=[],a=0,u=1;ud(t,(function(t){var c=a++,s=!1;u++,rd(e,n,t).then((function(t){s||(s=!0,i[c]=t,--u||r(i))}),o)})),--u||r(i)}));return i.error&&o(i.value),e.promise}});var cd=lu,sd=pf.CONSTRUCTOR,fd=Js,ld=vr,dd=Ie,pd=sa,hd=fd&&fd.prototype;if(cd({target:"Promise",proto:!0,forced:sd,real:!0},{catch:function(t){return this.then(void 0,t)}}),dd(fd)){var vd=ld("Promise").prototype.catch;hd.catch!==vd&&pd(hd,"catch",vd,{unsafe:!0})}var yd=dr,gd=qr,md=hf,bd=Ys,wd=Yl;lu({target:"Promise",stat:!0,forced:ed},{race:function(t){var n=this,e=md.f(n),r=e.reject,o=bd((function(){var o=gd(n.resolve);wd(t,(function(t){yd(o,n,t).then(e.resolve,r)}))}));return o.error&&r(o.value),e.promise}});var Sd=dr,Od=hf;lu({target:"Promise",stat:!0,forced:pf.CONSTRUCTOR},{reject:function(t){var n=Od.f(this);return Sd(n.reject,void 0,t),n.promise}});var jd=sr,Ed=Xe,Td=hf,xd=lu,Ad=pf.CONSTRUCTOR,Md=function(t,n){if(jd(t),Ed(n)&&n.constructor===t)return n;var e=Td.f(t);return(0,e.resolve)(n),e.promise};vr("Promise"),xd({target:"Promise",stat:!0,forced:Ad},{resolve:function(t){return Md(this,t)}});var kd={},Pd=oe,Id=ir,Cd=Ze,Rd=sr,Ld=Yi,Nd=hu;kd.f=Pd&&!Id?Object.defineProperties:function(t,n){Rd(t);for(var e,r=Ld(n),o=Nd(n),i=o.length,a=0;i>a;)Cd.f(t,e=o[a++],r[e]);return t};var Dd,Fd=sr,_d=kd,$d=Na,qd=Go,zd=Uc,Wd=er,Gd="prototype",Bd="script",Ud=Wo("IE_PROTO"),Hd=function(){},Vd=function(t){return"<"+Bd+">"+t+""},Kd=function(t){t.write(Vd("")),t.close();var n=t.parentWindow.Object;return t=null,n},Yd=function(){try{Dd=new ActiveXObject("htmlfile")}catch(t){}var t,n,e;Yd="undefined"!=typeof document?document.domain&&Dd?Kd(Dd):(n=Wd("iframe"),e="java"+Bd+":",n.style.display="none",zd.appendChild(n),n.src=String(e),(t=n.contentWindow.document).open(),t.write(Vd("document.F=Object")),t.close(),t.F):Kd(Dd);for(var r=$d.length;r--;)delete Yd[Gd][$d[r]];return Yd()};qd[Ud]=!0;var Jd=Object.create||function(t,n){var e;return null!==t?(Hd[Gd]=Fd(t),e=new Hd,Hd[Gd]=null,e[Ud]=t):e=Yd(),void 0===n?e:_d.f(e,n)},Xd=fo,Zd=Jd,Qd=Ze.f,tp=Xd("unscopables"),np=Array.prototype;void 0===np[tp]&&Qd(np,tp,{configurable:!0,value:Zd(null)});var ep,rp,op,ip=function(t){np[tp][t]=!0},ap=!re((function(){function t(){}return t.prototype.constructor=null,Object.getPrototypeOf(new t)!==t.prototype})),up=we,cp=Ie,sp=ge,fp=ap,lp=Wo("IE_PROTO"),dp=Object,pp=dp.prototype,hp=fp?dp.getPrototypeOf:function(t){var n=sp(t);if(up(n,lp))return n[lp];var e=n.constructor;return cp(e)&&n instanceof e?e.prototype:n instanceof dp?pp:null},vp=re,yp=Ie,gp=Xe,mp=hp,bp=sa,wp=fo("iterator"),Sp=!1;[].keys&&("next"in(op=[].keys())?(rp=mp(mp(op)))!==Object.prototype&&(ep=rp):Sp=!0);var Op=!gp(ep)||vp((function(){var t={};return ep[wp].call(t)!==t}));Op&&(ep={}),yp(ep[wp])||bp(ep,wp,(function(){return this}));var jp={IteratorPrototype:ep,BUGGY_SAFARI_ITERATORS:Sp},Ep=jp.IteratorPrototype,Tp=Jd,xp=Do,Ap=Qu,Mp=hl,kp=function(){return this},Pp=lu,Ip=dr,Cp=Ie,Rp=function(t,n,e,r){var o=n+" Iterator";return t.prototype=Tp(Ep,{next:xp(+!r,e)}),Ap(t,o,!1),Mp[o]=kp,t},Lp=hp,Np=Yu,Dp=Qu,Fp=$o,_p=sa,$p=hl,qp=xe.PROPER,zp=xe.CONFIGURABLE,Wp=jp.IteratorPrototype,Gp=jp.BUGGY_SAFARI_ITERATORS,Bp=fo("iterator"),Up="keys",Hp="values",Vp="entries",Kp=function(){return this},Yp=function(t,n,e,r,o,i,a){Rp(e,n,r);var u,c,s,f=function(t){if(t===o&&v)return v;if(!Gp&&t&&t in p)return p[t];switch(t){case Up:case Hp:case Vp:return function(){return new e(this,t)}}return function(){return new e(this)}},l=n+" Iterator",d=!1,p=t.prototype,h=p[Bp]||p["@@iterator"]||o&&p[o],v=!Gp&&h||f(o),y="Array"===n&&p.entries||h;if(y&&(u=Lp(y.call(new t)))!==Object.prototype&&u.next&&(Lp(u)!==Wp&&(Np?Np(u,Wp):Cp(u[Bp])||_p(u,Bp,Kp)),Dp(u,l,!0)),qp&&o===Hp&&h&&h.name!==Hp&&(zp?Fp(p,"name",Hp):(d=!0,v=function(){return Ip(h,this)})),o)if(c={values:f(Hp),keys:i?v:f(Up),entries:f(Vp)},a)for(s in c)(Gp||d||!(s in p))&&_p(p,s,c[s]);else Pp({target:n,proto:!0,forced:Gp||d},c);return p[Bp]!==v&&_p(p,Bp,v,{name:o}),$p[n]=v,c},Jp=function(t,n){return{value:t,done:n}},Xp=Yi,Zp=ip,Qp=hl,th=ri,nh=Ze.f,eh=Yp,rh=Jp,oh=oe,ih="Array Iterator",ah=th.set,uh=th.getterFor(ih),ch=eh(Array,"Array",(function(t,n){ah(this,{type:ih,target:Xp(t),index:0,kind:n})}),(function(){var t=uh(this),n=t.target,e=t.index++;if(!n||e>=n.length)return t.target=void 0,rh(void 0,!0);switch(t.kind){case"keys":return rh(e,!1);case"values":return rh(n[e],!1)}return rh([e,n[e]],!1)}),"values"),sh=Qp.Arguments=Qp.Array;if(Zp("keys"),Zp("values"),Zp("entries"),oh&&"values"!==sh.name)try{nh(sh,"name",{value:"values"})}catch(t){}var fh=Fu,lh=String,dh=function(t){if("Symbol"===fh(t))throw new TypeError("Cannot convert a Symbol value to a string");return lh(t)},ph=fe,hh=ha,vh=dh,yh=he,gh=ph("".charAt),mh=ph("".charCodeAt),bh=ph("".slice),wh=function(t){return function(n,e){var r,o,i=vh(yh(n)),a=hh(e),u=i.length;return a<0||a>=u?t?"":void 0:(r=mh(i,a))<55296||r>56319||a+1===u||(o=mh(i,a+1))<56320||o>57343?t?gh(i,a):r:t?bh(i,a,a+2):o-56320+(r-55296<<10)+65536}},Sh={codeAt:wh(!1),charAt:wh(!0)}.charAt,Oh=dh,jh=ri,Eh=Yp,Th=Jp,xh="String Iterator",Ah=jh.set,Mh=jh.getterFor(xh);Eh(String,"String",(function(t){Ah(this,{type:xh,string:Oh(t),index:0})}),(function(){var t,n=Mh(this),e=n.string,r=n.index;return r>=e.length?Th(void 0,!0):(t=Sh(e,r),n.index+=t.length,Th(t,!1))}));var kh={exports:{}},Ph={},Ih=So,Ch=Ze,Rh=Do,Lh=function(t,n,e){var r=Ih(n);r in t?Ch.f(t,r,Rh(0,e)):t[r]=e},Nh=ma,Dh=ja,Fh=Lh,_h=Array,$h=Math.max,qh=function(t,n,e){for(var r=Dh(t),o=Nh(n,r),i=Nh(void 0===e?r:e,r),a=_h($h(i-o,0)),u=0;om;m++)if((u||m in v)&&(p=g(d=v[m],m,h),t))if(n)w[m]=p;else if(p)switch(t){case 3:return!0;case 5:return d;case 6:return m;case 2:Xv(w,d)}else switch(t){case 4:return!1;case 7:Xv(w,d)}return i?-1:r||o?o:w}},Qv={forEach:Zv(0),map:Zv(1),filter:Zv(2),some:Zv(3),every:Zv(4),find:Zv(5),findIndex:Zv(6),filterReject:Zv(7)},ty=fe,ny=Dv,ey=vv.getWeakData,ry=uc,oy=sr,iy=le,ay=Xe,uy=Yl,cy=we,sy=ri.set,fy=ri.getterFor,ly=Qv.find,dy=Qv.findIndex,py=ty([].splice),hy=0,vy=function(t){return t.frozen||(t.frozen=new yy)},yy=function(){this.entries=[]},gy=function(t,n){return ly(t.entries,(function(t){return t[0]===n}))};yy.prototype={get:function(t){var n=gy(this,t);if(n)return n[1]},has:function(t){return!!gy(this,t)},set:function(t,n){var e=gy(this,t);e?e[1]=n:this.entries.push([t,n])},delete:function(t){var n=dy(this.entries,(function(n){return n[0]===t}));return~n&&py(this.entries,n,1),!!~n}};var my={getConstructor:function(t,n,e,r){var o=t((function(t,o){ry(t,i),sy(t,{type:n,id:hy++,frozen:void 0}),iy(o)||uy(o,t[r],{that:t,AS_ENTRIES:e})})),i=o.prototype,a=fy(n),u=function(t,n,e){var r=a(t),o=ey(oy(n),!0);return!0===o?vy(r).set(n,e):o[r.id]=e,t};return ny(i,{delete:function(t){var n=a(this);if(!ay(t))return!1;var e=ey(t);return!0===e?vy(n).delete(t):e&&cy(e,n.id)&&delete e[n.id]},has:function(t){var n=a(this);if(!ay(t))return!1;var e=ey(t);return!0===e?vy(n).has(t):e&&cy(e,n.id)}}),ny(i,e?{get:function(t){var n=a(this);if(ay(t)){var e=ey(t);return!0===e?vy(n).get(t):e?e[n.id]:void 0}},set:function(t,n){return u(this,t,n)}}:{add:function(t){return u(this,t,!0)}}),o}};Lv("WeakSet",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),my);var by={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0},wy=er("span").classList,Sy=wy&&wy.constructor&&wy.constructor.prototype,Oy=Sy===Object.prototype?void 0:Sy,jy=Re,Ey=by,Ty=Oy,xy=ch,Ay=$o,My=Qu,ky=fo("iterator"),Py=xy.values,Iy=function(t,n){if(t){if(t[ky]!==Py)try{Ay(t,ky,Py)}catch(n){t[ky]=Py}if(My(t,n,!0),Ey[n])for(var e in xy)if(t[e]!==xy[e])try{Ay(t,e,xy[e])}catch(n){t[e]=xy[e]}}};for(var Cy in Ey)Iy(jy[Cy]&&jy[Cy].prototype,Cy);Iy(Ty,"DOMTokenList");var Ry=re,Ly=Er,Ny=fo("species"),Dy=function(t){return Ly>=51||!Ry((function(){var n=[];return(n.constructor={})[Ny]=function(){return{foo:1}},1!==n[t](Boolean).foo}))},Fy=lu,_y=_v,$y=Tc,qy=Xe,zy=ma,Wy=ja,Gy=Yi,By=Lh,Uy=fo,Hy=Hc,Vy=Dy("slice"),Ky=Uy("species"),Yy=Array,Jy=Math.max;Fy({target:"Array",proto:!0,forced:!Vy},{slice:function(t,n){var e,r,o,i=Gy(this),a=Wy(i),u=zy(t,a),c=zy(void 0===n?a:n,a);if(_y(i)&&(e=i.constructor,($y(e)&&(e===Yy||_y(e.prototype))||qy(e)&&null===(e=e[Ky]))&&(e=void 0),e===Yy||void 0===e))return Hy(i,u,c);for(r=new(void 0===e?Yy:e)(Jy(c-u,0)),o=0;u1?arguments[1]:void 0,n.length)),r=mg(t);return Og?Og(n,r,e):jg(n,e,e+r.length)===r}});var xg=Qv.forEach,Ag=Re,Mg=by,kg=Oy,Pg=Zy("forEach")?[].forEach:function(t){return xg(this,t,arguments.length>1?arguments[1]:void 0)},Ig=$o,Cg=function(t){if(t&&t.forEach!==Pg)try{Ig(t,"forEach",Pg)}catch(n){t.forEach=Pg}};for(var Rg in Mg)Mg[Rg]&&Cg(Ag[Rg]&&Ag[Rg].prototype);Cg(kg);var Lg=oe,Ng=re,Dg=fe,Fg=hp,_g=hu,$g=Yi,qg=Dg(Li.f),zg=Dg([].push),Wg=Lg&&Ng((function(){var t=Object.create(null);return t[2]=2,!qg(t,2)})),Gg=function(t){return function(n){for(var e,r=$g(n),o=_g(r),i=Wg&&null===Fg(r),a=o.length,u=0,c=[];a>u;)e=o[u++],Lg&&!(i?e in r:qg(r,e))||zg(c,t?[e,r[e]]:r[e]);return c}},Bg={entries:Gg(!0),values:Gg(!1)}.entries;function Ug(t){return null!=t&&!Number.isNaN(t)}function Hg(t,n){return+Ug(n)-+Ug(t)||e(t,n)}function Vg(t){return isFinite(t)?t:NaN}function Kg(t){return t>0&&isFinite(t)?t:NaN}function Yg(t){return t<0&&isFinite(t)?t:NaN}lu({target:"Object",stat:!0},{entries:function(t){return Bg(t)}});const Jg=/^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/;function Xg(t,n){return Jg.test(t+="")?new Date(t):"function"==typeof n?n(t):n}const Zg=new Map([["second",r],["minute",o],["hour",i],["day",a],["week",u],["month",c],["quarter",c.every(3)],["half",c.every(6)],["year",s],["monday",f],["tuesday",l],["wednesday",d],["thursday",p],["friday",h],["saturday",v],["sunday",y]]),Qg=new Map([["second",g],["minute",m],["hour",b],["day",w],["week",S],["month",O],["quarter",O.every(3)],["half",O.every(6)],["year",j],["monday",E],["tuesday",T],["wednesday",x],["thursday",A],["friday",M],["saturday",k],["sunday",P]]);function tm(t){const n=Zg.get(`${t}`.toLowerCase());if(!n)throw new Error(`unknown interval: ${t}`);return n}function nm(t){const n=Qg.get(`${t}`.toLowerCase());if(!n)throw new Error(`unknown interval: ${t}`);return n}const em=Object.getPrototypeOf(Uint8Array),rm=Object.prototype.toString,om=t=>()=>t;function im(t){return t instanceof em?t:fm(t,am,Float64Array)}function am(t){return null==t?NaN:Number(t)}function um(t){return fm(t,cm)}function cm(t){return t instanceof Date&&!isNaN(t)?t:"string"==typeof t?Xg(t):null==t||isNaN(t=+t)?void 0:new Date(t)}function sm(t){return null==t||t instanceof Array||t instanceof em?t:Array.from(t)}function fm(t,n,e=Array){return null==t?t:t instanceof e?t.map(n):e.from(t,n)}function lm(t,n=Array){return t instanceof n?t.slice():n.from(t)}function dm(t){return function(t){return t?.toString===rm}(t)&&(void 0!==t.type||void 0!==t.domain)}function pm(t,n){if(null!=t){if("number"==typeof t){0Math.floor(t*n)/n,offset:t=>(t*n+1)/n,range:(t,e)=>C(Math.ceil(t*n),e*n).map((t=>t/n))}:{floor:t=>Math.floor(t/n)*n,offset:t=>t+n,range:(t,e)=>C(Math.ceil(t/n),e/n).map((t=>t*n))}}if("string"==typeof t)return("time"===n?tm:nm)(t);if("function"!=typeof t.floor)throw new Error("invalid interval; missing floor method");if("function"!=typeof t.offset)throw new Error("invalid interval; missing offset method");return t}}function hm(t,n){if((t=pm(t,n))&&"function"!=typeof t.range)throw new Error("invalid interval: missing range method");return t}function vm(t){for(const n of t){if(null==n)continue;const t=typeof n;return"string"===t||"boolean"===t}}function ym(t){for(const n of t)if(null!=n)return n instanceof Date}function gm(t){for(const n of t)if(null!=n)return"string"==typeof n&&isNaN(n)&&Xg(n)}function mm(t){for(const n of t)if(null!=n){if("string"!=typeof n)return!1;if(n.trim())return!isNaN(n)}}function bm(t){if(null==t)return;const n=t[0],e=t[t.length-1];return I(n,e)}const wm=Symbol("position"),Sm=Symbol("color"),Om=Symbol("radius"),jm=Symbol("length"),Em=Symbol("opacity"),Tm=Symbol("symbol"),xm=new Map([["x",wm],["y",wm],["fx",wm],["fy",wm],["r",Om],["color",Sm],["opacity",Em],["symbol",Tm],["length",jm]]),Am=2/Math.sqrt(3),Mm=new Map([["asterisk",R],["circle",L],["cross",N],["diamond",D],["diamond2",F],["hexagon",{draw(t,n){const e=Math.sqrt(n/Math.PI),r=e*Am,o=r/2;t.moveTo(0,r),t.lineTo(e,o),t.lineTo(e,-o),t.lineTo(0,-r),t.lineTo(-e,-o),t.lineTo(-e,o),t.closePath()}}],["plus",_],["square",$],["square2",q],["star",z],["times",W],["triangle",G],["triangle2",B],["wye",U]]);function km(t){if(null==t||function(t){return t&&"function"==typeof t.draw}(t))return t;const n=Mm.get(`${t}`.toLowerCase());if(n)return n;throw new Error(`invalid symbol: ${t}`)}function Pm(t){console.warn(t)}const Im=new Map([["accent",H],["category10",V],["dark2",K],["paired",Y],["pastel1",J],["pastel2",X],["set1",Z],["set2",Q],["set3",tt],["tableau10",nt],["brbg",Rm(zt,rt)],["prgn",Rm(Wt,ot)],["piyg",Rm(Gt,it)],["puor",Rm(Bt,at)],["rdbu",Rm(Ut,ut)],["rdgy",Rm(Ht,ct)],["rdylbu",Rm(Vt,st)],["rdylgn",Rm(Kt,ft)],["spectral",Rm(Yt,lt)],["burd",Lm(Ut,ut)],["buylrd",Lm(Vt,st)],["blues",Cm(Jt,dt)],["greens",Cm(Xt,pt)],["greys",Cm(Zt,ht)],["oranges",Cm(Qt,gt)],["purples",Cm(tn,vt)],["reds",Cm(nn,yt)],["turbo",Nm(mt)],["viridis",Nm(bt)],["magma",Nm(wt)],["inferno",Nm(St)],["plasma",Nm(Ot)],["cividis",Nm(jt)],["cubehelix",Nm(Et)],["warm",Nm(Tt)],["cool",Nm(xt)],["bugn",Cm(en,At)],["bupu",Cm(rn,Mt)],["gnbu",Cm(on,kt)],["orrd",Cm(an,Pt)],["pubu",Cm(un,Ct)],["pubugn",Cm(cn,It)],["purd",Cm(sn,Rt)],["rdpu",Cm(fn,Lt)],["ylgn",Cm(ln,Dt)],["ylgnbu",Cm(dn,Nt)],["ylorbr",Cm(pn,Ft)],["ylorrd",Cm(hn,_t)],["rainbow",Dm($t)],["sinebow",Dm(qt)]]);function Cm(t,n){return({length:e})=>1===e?[t[3][1]]:2===e?[t[3][1],t[3][2]]:(e=Math.max(3,Math.floor(e)))>9?et(n,e):t[e]}function Rm(t,n){return({length:e})=>2===e?[t[3][0],t[3][2]]:(e=Math.max(3,Math.floor(e)))>11?et(n,e):t[e]}function Lm(t,n){return({length:e})=>2===e?[t[3][2],t[3][0]]:(e=Math.max(3,Math.floor(e)))>11?et((t=>n(1-t)),e):t[e].slice().reverse()}function Nm(t){return({length:n})=>et(t,Math.max(2,Math.floor(n)))}function Dm(t){return({length:n})=>et(t,Math.floor(n)+1).slice(0,-1)}function Fm(t){const n=`${t}`.toLowerCase();if(!Im.has(n))throw new Error(`unknown ordinal scheme: ${n}`);return Im.get(n)}function _m(t,n){const e=Fm(t),r="function"==typeof e?e({length:n}):e;return r.length!==n?r.slice(0,n):r}const $m=new Map([["brbg",rt],["prgn",ot],["piyg",it],["puor",at],["rdbu",ut],["rdgy",ct],["rdylbu",st],["rdylgn",ft],["spectral",lt],["burd",t=>ut(1-t)],["buylrd",t=>st(1-t)],["blues",dt],["greens",pt],["greys",ht],["purples",vt],["reds",yt],["oranges",gt],["turbo",mt],["viridis",bt],["magma",wt],["inferno",St],["plasma",Ot],["cividis",jt],["cubehelix",Et],["warm",Tt],["cool",xt],["bugn",At],["bupu",Mt],["gnbu",kt],["orrd",Pt],["pubugn",It],["pubu",Ct],["purd",Rt],["rdpu",Lt],["ylgnbu",Nt],["ylgn",Dt],["ylorbr",Ft],["ylorrd",_t],["rainbow",$t],["sinebow",qt]]);function qm(t){const n=`${t}`.toLowerCase();if(!$m.has(n))throw new Error(`unknown quantitative scheme: ${n}`);return $m.get(n)}const zm=new Set(["brbg","prgn","piyg","puor","rdbu","rdgy","rdylbu","rdylgn","spectral","burd","buylrd"]);function Wm(t){return null!=t&&zm.has(`${t}`.toLowerCase())}const Gm=t=>n=>t(1-n),Bm=[0,1],Um=new Map([["number",On],["rgb",An],["hsl",Cn],["hcl",Rn],["lab",Ln]]);function Hm(t){const n=`${t}`.toLowerCase();if(!Um.has(n))throw new Error(`unknown interpolator: ${n}`);return Um.get(n)}function Vm(t,n,e,{type:r,nice:o,clamp:i,zero:a,domain:u=Xm(t,e),unknown:c,round:s,scheme:f,interval:l,range:d=(xm.get(t)===Om?Qm(e,u):xm.get(t)===jm?tb(e,u):xm.get(t)===Em?Bm:void 0),interpolate:p=(xm.get(t)===Sm?null==f&&void 0!==d?An:qm(void 0!==f?f:"cyclical"===r?"rainbow":"turbo"):s?Mn:On),reverse:h}){if(l=hm(l,r),"cyclical"!==r&&"sequential"!==r||(r="linear"),h=!!h,"function"!=typeof p&&(p=Hm(p)),1===p.length?(h&&(p=Gm(p),h=!1),void 0===d&&2===(d=Float64Array.from(u,((t,n)=>n/(u.length-1)))).length&&(d=Bm),n.interpolate((d===Bm?om:rb)(p))):n.interpolate(p),a){const[t,n]=wn(u);(t>0||n<0)&&(bm(u=lm(u))!==Math.sign(t)?u[u.length-1]=0:u[0]=0)}return h&&(u=jn(u)),n.domain(u).unknown(c),o&&(n.nice(function(t,n){return!0===t?void 0:"number"==typeof t?t:function(t,n){if((t=hm(t,n))&&"function"!=typeof t.ceil)throw new Error("invalid interval: missing ceil method");return t}(t,n)}(o,r)),u=n.domain()),void 0!==d&&n.range(d),i&&n.clamp(i),{type:r,domain:u,range:d,scale:n,interpolate:p,interval:l}}function Km(t,n,{exponent:e=1,...r}){return Vm(t,yn().exponent(e),n,{...r,type:"pow"})}function Ym(t,n,{domain:e=[0],unknown:r,scheme:o="rdylbu",interpolate:i,range:a=(void 0!==i?et(i,e.length+1):xm.get(t)===Sm?_m(o,e.length+1):void 0),reverse:u}){const c=bm(e=sm(e));if(!isNaN(c)&&!function(t,n){for(let e=1,r=t.length,o=t[0];evoid 0===t?t:kn(t,n))),xn(t,(({value:t})=>void 0===t?t:xn(t,n)))]:[0,1]}function Xm(t,n){const e=xm.get(t);return(e===Om||e===Em||e===jm?Zm:Jm)(n)}function Zm(t){return[0,t.length?xn(t,(({value:t})=>void 0===t?t:xn(t,Vg))):1]}function Qm(t,n){const e=t.find((({radius:t})=>void 0!==t));if(void 0!==e)return[0,e.radius];const r=Pn(t,.5,(({value:t})=>void 0===t?NaN:Pn(t,.25,Kg))),o=n.map((t=>3*Math.sqrt(t/r))),i=30/xn(o);return i<1?o.map((t=>t*i)):o}function tb(t,n){const e=In(t,(({value:t})=>void 0===t?NaN:In(t,Math.abs))),r=n.map((t=>12*t/e)),o=60/xn(r);return o<1?r.map((t=>t*o)):r}function nb(t){for(const{value:n}of t)if(void 0!==n)for(let e of n){if(e>0)return Jm(t,Kg);if(e<0)return Jm(t,Yg)}return[1,10]}function eb(t){const n=[];for(const{value:e}of t)if(void 0!==e)for(const t of e)n.push(t);return n}function rb(t){return(n,e)=>r=>t(n+r*(e-n))}function ob(t,n,e,r,{type:o,nice:i,clamp:a,domain:u=Jm(r),unknown:c,pivot:s=0,scheme:f,range:l,symmetric:d=!0,interpolate:p=(xm.get(t)===Sm?null==f&&void 0!==l?An:qm(void 0!==f?f:"rdbu"):On),reverse:h}){s=+s;let[v,y]=u;if(I(v,y)<0&&([v,y]=[y,v],h=!h),v=Math.min(v,s),y=Math.max(y,s),"function"!=typeof p&&(p=Hm(p)),void 0!==l&&(p=1===p.length?rb(p)(...l):$n(p,l)),h&&(p=Gm(p)),d){const t=e.apply(s),n=t-e.apply(v),r=e.apply(y)-t;nr&&(y=e.invert(t+n))}return n.domain([v,s,y]).unknown(c).interpolator(p),a&&n.clamp(a),i&&n.nice(i),{type:o,domain:[v,y],pivot:s,interpolate:p,scale:n}}function ib(t,n,{exponent:e=1,...r}){return ob(t,Dn().exponent(e=+e),function(t){return.5===t?sb:{apply:n=>Math.sign(n)*Math.pow(Math.abs(n),t),invert:n=>Math.sign(n)*Math.pow(Math.abs(n),1/t)}}(e),n,{...r,type:"diverging-pow"})}function ab(t,n,{constant:e=1,...r}){return ob(t,_n().constant(e=+e),function(t){return{apply:n=>Math.sign(n)*Math.log1p(Math.abs(n/t)),invert:n=>Math.sign(n)*Math.expm1(Math.abs(n))*t}}(e),n,r)}const ub={apply:t=>t,invert:t=>t},cb={apply:Math.log,invert:Math.exp},sb={apply:t=>Math.sign(t)*Math.sqrt(Math.abs(t)),invert:t=>Math.sign(t)*(t*t)};function fb(t,n,e,r){return Vm(t,n,e,r)}const lb=Symbol("ordinal");function db(t,n,e,{type:r,interval:o,domain:i,range:a,reverse:u,hint:c}){return o=hm(o,r),void 0===i&&(i=vb(e,o,t)),"categorical"!==r&&r!==lb||(r="ordinal"),u&&(i=jn(i)),n.domain(i),void 0!==a&&("function"==typeof a&&(a=a(i)),n.range(a)),{type:r,domain:i,range:a,scale:n,hint:c,interval:o}}function pb(t,n,{type:e,interval:r,domain:o,range:i,scheme:a,unknown:u,...c}){let s;if(r=hm(r,e),void 0===o&&(o=vb(n,r,t)),xm.get(t)===Tm)s=function(t){return{fill:yb(t,"fill"),stroke:yb(t,"stroke")}}(n),i=void 0===i?function(t){return n=t.fill,null==n||function(t){return/^\s*none\s*$/i.test(t)}(n)?Kn:Yn;var n}(s):fm(i,km);else if(xm.get(t)===Sm&&(void 0!==i||"ordinal"!==e&&e!==lb||(i=function(t,n="greys"){const e=new Set,[r,o]=_m(n,2);for(const n of t)if(null!=n)if(!0===n)e.add(o);else{if(!1!==n)return;e.add(r)}return[...e]}(o,a),void 0!==i&&(a=void 0)),void 0===a&&void 0===i&&(a="ordinal"===e?"turbo":"tableau10"),void 0!==a))if(void 0!==i){const t=qm(a),n=i[0],e=i[1]-i[0];i=({length:r})=>et((r=>t(n+e*r)),r)}else i=Fm(a);if(u===Wn)throw new Error(`implicit unknown on ${t} scale is not supported`);return db(t,Gn().unknown(u),n,{...c,type:e,domain:o,range:i,hint:s})}function hb(t,n,e,r){let{round:o}=e;return void 0!==o&&t.round(o=!!o),(t=db(r,t,n,e)).round=o,t}function vb(t,n,e){const r=new Hn;for(const{value:n,domain:e}of t){if(void 0!==e)return e();if(void 0!==n)for(const t of n)r.add(t)}if(void 0!==n){const[t,e]=wn(r).map(n.floor,n);return n.range(t,n.offset(e))}if(r.size>1e4&&xm.get(e)===wm)throw new Error(`implicit ordinal domain of ${e} scale has more than 10,000 values`);return Vn(r,Hg)}function yb(t,n){let e;for(const{hint:r}of t){const t=r?.[n];if(void 0!==t)if(void 0===e)e=t;else if(e!==t)return}return e}function gb(t,n,e){return function(t,n=[],e={}){const r=function(t,n,{type:e,domain:r,range:o,scheme:i,pivot:a,projection:u}){if("fx"===t||"fy"===t)return"band";"x"!==t&&"y"!==t||null==u||(e=bb);for(const{type:t}of n)if(void 0!==t)if(void 0===e)e=t;else if(e!==t)throw new Error(`scale incompatible with channel: ${e} !== ${t}`);if(e===bb)return;if(void 0!==e)return e;if(void 0===r&&!n.some((({value:t})=>void 0!==t)))return;const c=xm.get(t);if(c===Om)return"sqrt";if(c===Em||c===jm)return"linear";if(c===Tm)return"ordinal";if((r||o||[]).length>2)return wb(c);if(void 0!==r)return vm(r)?wb(c):ym(r)?"utc":c!==Sm||null==a&&!Wm(i)?"linear":"diverging";const s=n.map((({value:t})=>t)).filter((t=>void 0!==t));return s.some(vm)?wb(c):s.some(ym)?"utc":c!==Sm||null==a&&!Wm(i)?"linear":"diverging"}(t,n,e);if(void 0===e.type&&void 0===e.domain&&void 0===e.range&&null==e.interval&&"fx"!==t&&"fy"!==t&&function({type:t}){return"ordinal"===t||"point"===t||"band"===t||t===lb}({type:r})){const e=n.map((({value:t})=>t)).filter((t=>void 0!==t));e.some(ym)?Pm(`Warning: some data associated with the ${t} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${mb(r)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${t} scale to "${mb(r)}".`):e.some(gm)?Pm(`Warning: some data associated with the ${t} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${mb(r)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${t} scale to "${mb(r)}".`):e.some(mm)&&Pm(`Warning: some data associated with the ${t} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${mb(r)}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${t} scale to "${mb(r)}".`)}switch(e.type=r,r){case"diverging":case"diverging-sqrt":case"diverging-pow":case"diverging-log":case"diverging-symlog":case"cyclical":case"sequential":case"linear":case"sqrt":case"threshold":case"quantile":case"pow":case"log":case"symlog":e=Sb(n,e,im);break;case"identity":switch(xm.get(t)){case wm:e=Sb(n,e,im);break;case Tm:e=Sb(n,e,Ob)}break;case"utc":case"time":e=Sb(n,e,um)}switch(r){case"diverging":return function(t,n,e){return ob(t,Nn(),ub,n,e)}(t,n,e);case"diverging-sqrt":return function(t,n,e){return ib(t,n,{...e,exponent:.5})}(t,n,e);case"diverging-pow":return ib(t,n,e);case"diverging-log":return function(t,n,{base:e=10,pivot:r=1,domain:o=Jm(n,r<0?Yg:Kg),...i}){return ob(t,Fn().base(e=+e),cb,n,{domain:o,pivot:r,...i})}(t,n,e);case"diverging-symlog":return ab(t,n,e);case"categorical":case"ordinal":case lb:return pb(t,n,e);case"cyclical":case"sequential":case"linear":return function(t,n,e){return Vm(t,vn(),n,e)}(t,n,e);case"sqrt":return function(t,n,e){return Km(t,n,{...e,exponent:.5})}(t,n,e);case"threshold":return Ym(t,0,e);case"quantile":return function(t,n,{range:e,quantiles:r=(void 0===e?5:(e=[...e]).length),n:o=r,scheme:i="rdylbu",domain:a=eb(n),unknown:u,interpolate:c,reverse:s}){return void 0===e&&(e=void 0!==c?et(c,o):xm.get(t)===Sm?_m(i,o):void 0),a.length>0&&(a=bn(a,void 0===e?{length:o}:e).quantiles()),Ym(t,0,{domain:a,range:e,reverse:s,unknown:u})}(t,n,e);case"quantize":return function(t,n,{range:e,n:r=(void 0===e?5:(e=[...e]).length),scheme:o="rdylbu",domain:i=Xm(t,n),unknown:a,interpolate:u,reverse:c}){const[s,f]=wn(i);let l;return void 0===e?(l=Sn(s,f,r),l[0]<=s&&l.splice(0,1),l[l.length-1]>=f&&l.pop(),r=l.length+1,e=void 0!==u?et(u,r):xm.get(t)===Sm?_m(o,r):void 0):(l=et(On(s,f),r+1).slice(1,-1),s instanceof Date&&(l=l.map((t=>new Date(t))))),bm(sm(i))<0&&l.reverse(),Ym(t,0,{domain:l,range:e,reverse:c,unknown:a})}(t,n,e);case"pow":return Km(t,n,e);case"log":return function(t,n,{base:e=10,domain:r=nb(n),...o}){return Vm(t,gn().base(e),n,{...o,domain:r})}(t,n,e);case"symlog":return function(t,n,{constant:e=1,...r}){return Vm(t,mn().constant(e),n,r)}(t,n,e);case"utc":return function(t,n,e){return fb(t,zn(),n,e)}(t,n,e);case"time":return function(t,n,e){return fb(t,qn(),n,e)}(t,n,e);case"point":return function(t,n,{align:e=.5,padding:r=.5,...o}){return hb(Bn().align(e).padding(r),n,o,t)}(t,n,e);case"band":return function(t,n,{align:e=.5,padding:r=.1,paddingInner:o=r,paddingOuter:i=("fx"===t||"fy"===t?0:r),...a}){return hb(Un().align(e).paddingInner(o).paddingOuter(i),n,a,t)}(t,n,e);case"identity":return xm.get(t)===wm?{type:"identity",scale:Tn()}:{type:"identity"};case void 0:return;default:throw new Error(`unknown scale type: ${r}`)}}(t,void 0===e?void 0:[{hint:e}],{...n})}function mb(t){return"symbol"==typeof t?t.description:t}const bb={toString:()=>"projection"};function wb(t){switch(t){case wm:return"point";case Sm:return lb;default:return"ordinal"}}function Sb(t,{domain:n,...e},r){for(const n of t)void 0!==n.value&&(n.value=r(n.value));return{domain:void 0===n?n:r(n),...e}}function Ob(t){return fm(t,km)}function jb({scale:t,type:n,domain:e,range:r,interpolate:o,interval:i,transform:a,percent:u,pivot:c}){if("identity"===n)return{type:"identity",apply:t=>t,invert:t=>t};const s=t.unknown?t.unknown():void 0;return{type:n,domain:lm(e),...void 0!==r&&{range:lm(r)},...void 0!==a&&{transform:a},...u&&{percent:u},...void 0!==s&&{unknown:s},...void 0!==i&&{interval:i},...void 0!==o&&{interpolate:o},...t.clamp&&{clamp:t.clamp()},...void 0!==c&&{pivot:c,symmetric:!1},...t.base&&{base:t.base()},...t.exponent&&{exponent:t.exponent()},...t.constant&&{constant:t.constant()},...t.align&&{align:t.align(),round:t.round()},...t.padding&&(t.paddingInner?{paddingInner:t.paddingInner(),paddingOuter:t.paddingOuter()}:{padding:t.padding()}),...t.bandwidth&&{bandwidth:t.bandwidth(),step:t.step()},apply:n=>t(n),...t.invert&&{invert:n=>t.invert(n)}}}var Eb,Tb;!function(t){t[t.SCROLL_NONE=0]="SCROLL_NONE",t[t.SCROLL_BACKWARD=1]="SCROLL_BACKWARD",t[t.SCROLL_FORWARD=2]="SCROLL_FORWARD"}(Eb||(Eb={})),function(t){t[t.TOP=0]="TOP",t[t.RIGHT=1]="RIGHT",t[t.BOTTOM=2]="BOTTOM",t[t.LEFT=3]="LEFT"}(Tb||(Tb={}));var xb="red";function Ab(t){try{var n=Object.keys(t)[0];return function(t={}){let n;for(const e in t)if(xm.has(e)&&dm(t[e])){if(void 0!==n)throw new Error("ambiguous scale definition; multiple scales found");n=jb(gb(e,t[e]))}if(void 0===n)throw new Error("invalid scale definition; no scale found");return n}((e={},r=n,o=Object.assign(Object.assign({},t[n]),{clamp:!0}),(r=ne(r))in e?Object.defineProperty(e,r,{value:o,enumerable:!0,configurable:!0,writable:!0}):e[r]=o,e))}catch(t){return null}var e,r,o}function Mb(t,n,e,r){Object.entries(function(t,n){var e={};return n.hasOwnProperty("opacity")?(e.fill=function(){return n.opacity.baseColor||xb},e["fill-opacity"]=function(n){return null==t?void 0:t.apply(n)}):e.fill=function(n){return"string"==typeof n&&(null==n?void 0:n.startsWith("#"))?n:null==t?void 0:t.apply(n)},e}(n,e)).forEach((function(n){var e=Xn(n,2),o=e[0],i=e[1];return t.style(o,(function(t){return i(r?t[r]:t)}))}))}var kb=TypeError,Pb=lu,Ib=re,Cb=_v,Rb=Xe,Lb=ge,Nb=ja,Db=function(t){if(t>9007199254740991)throw kb("Maximum allowed index exceeded");return t},Fb=Lh,_b=Uv,$b=Dy,qb=Er,zb=fo("isConcatSpreadable"),Wb=qb>=51||!Ib((function(){var t=[];return t[zb]=!1,t.concat()[0]!==t})),Gb=function(t){if(!Rb(t))return!1;var n=t[zb];return void 0!==n?!!n:Cb(t)};Pb({target:"Array",proto:!0,arity:1,forced:!Wb||!$b("concat")},{concat:function(t){var n,e,r,o,i,a=Lb(this),u=_b(a,0),c=0;for(n=-1,r=arguments.length;n1?arguments[1]:void 0);n=n?n.next:e.first;)for(r(n.value,n.key,this);n&&n.removed;)n=n.previous},has:function(t){return!!c(this,t)}}),Xb(i,e?{get:function(t){var n=c(this,t);return n&&n.value},set:function(t,n){return u(this,0===t?0:t,n)}}:{add:function(t){return u(this,t=0===t?0:t,t)}}),iw&&Jb(i,"size",{configurable:!0,get:function(){return a(this).size}}),o},setStrong:function(t,n,e){var r=n+" Iterator",o=cw(n),i=cw(r);ew(t,n,(function(t,n){uw(this,{type:r,target:t,state:o(t),kind:n,last:void 0})}),(function(){for(var t=i(this),n=t.kind,e=t.last;e&&e.removed;)e=e.previous;return t.target&&(t.last=e=e?e.next:t.state.first)?rw("keys"===n?e.key:"values"===n?e.value:[e.key,e.value],!1):(t.target=void 0,rw(void 0,!0))}),e?"entries":"values",!e,!0),ow(n)}};Lv("Map",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),sw);var fw=Dr,lw=TypeError,dw=qh,pw=Math.floor,hw=function(t,n){var e=t.length,r=pw(e/2);return e<8?vw(t,n):yw(t,hw(dw(t,0,r),n),hw(dw(t,r),n),n)},vw=function(t,n){for(var e,r,o=t.length,i=1;i0;)t[r]=t[--r];r!==i++&&(t[r]=e)}return t},yw=function(t,n,e,r){for(var o=n.length,i=e.length,a=0,u=0;a3)){if(Lw)return!0;if(Dw)return Dw<603;var t,n,e,r,o="";for(t=65;t<76;t++){switch(n=String.fromCharCode(t),t){case 66:case 69:case 70:case 72:e=3;break;case 68:case 71:e=4;break;default:e=2}for(r=0;r<47;r++)Fw.push({k:n+r,v:e})}for(Fw.sort((function(t,n){return n.v-t.v})),r=0;rkw(e)?1:-1}}(t)),e=Aw(o),r=0;r1?arguments[1]:void 0)}}),Uw("includes");var Hw=Qv.map;lu({target:"Array",proto:!0,forced:!Dy("map")},{map:function(t){return Hw(this,t,arguments.length>1?arguments[1]:void 0)}});var Vw=Qv.filter;lu({target:"Array",proto:!0,forced:!Dy("filter")},{filter:function(t){return Vw(this,t,arguments.length>1?arguments[1]:void 0)}});var Kw=sr,Yw=Nl,Jw=Bc,Xw=dr,Zw=ge,Qw=function(t,n,e,r){try{return r?n(Kw(e)[0],e[1]):n(e)}catch(n){Yw(t,"throw",n)}},tS=ml,nS=Tc,eS=ja,rS=Lh,oS=Il,iS=El,aS=Array,uS=function(t){var n=Zw(t),e=nS(this),r=arguments.length,o=r>1?arguments[1]:void 0,i=void 0!==o;i&&(o=Jw(o,r>2?arguments[2]:void 0));var a,u,c,s,f,l,d=iS(n),p=0;if(!d||this===aS&&tS(d))for(a=eS(n),u=e?new this(a):aS(a);a>p;p++)l=i?o(n[p],p):n[p],rS(u,p,l);else for(f=(s=oS(n,d)).next,u=e?new this:[];!(c=Xw(f,s)).done;p++)l=i?Qw(s,o,[c.value,p],!0):c.value,rS(u,p,l);return u.length=p,u};lu({target:"Array",stat:!0,forced:!td((function(t){Array.from(t)}))},{from:uS});var cS="\t\n\v\f\r                　\u2028\u2029\ufeff",sS=he,fS=dh,lS=cS,dS=fe("".replace),pS=RegExp("^["+lS+"]+"),hS=RegExp("(^|[^"+lS+"])["+lS+"]+$"),vS=function(t){return function(n){var e=fS(sS(n));return 1&t&&(e=dS(e,pS,"")),2&t&&(e=dS(e,hS,"$1")),e}},yS={start:vS(1),end:vS(2),trim:vS(3)},gS=xe.PROPER,mS=re,bS=cS,wS=yS.trim;lu({target:"String",proto:!0,forced:function(t){return mS((function(){return!!bS[t]()||"​…᠎"!=="​…᠎"[t]()||gS&&bS[t].name!==t}))}("trim")},{trim:function(){return wS(this)}});var SS,OS,jS,ES=".ch-plugin-legend-lite",TS={enabled:!0,itemSelector:null,width:10,height:10,gutter:2,radius:0,includeBlank:!1},xS=function(){function n(t){!function(t,n){if(!(t instanceof n))throw new TypeError("Cannot call a class as a function")}(this,n),SS.add(this),this.name="LegendLite",this.calendar=t,this.root=null,this.shown=!1,this.options=TS}var e,r,o;return e=n,r=[{key:"setup",value:function(t){this.options=Object.assign(Object.assign({},this.options),t)}},{key:"paint",value:function(){var n=this.options,e=n.enabled,r=n.itemSelector;if(!e||r&&t(r).empty())return this.destroy();this.shown=!0,this.root=t(r||this.calendar.options.options.itemSelector),this.root.select(ES).empty()?this.root=this.root.append("div").attr("class",ES.slice(1)):this.root=this.root.select(ES);var o=og(this,SS,"m",OS).call(this);return this.root.selectAll("*").remove(),this.root.append((function(){return o.node()})),Promise.resolve()}},{key:"destroy",value:function(){return null!==this.root&&(this.root.remove(),this.root=null),Promise.resolve()}}],r&&Jn(e.prototype,r),o&&Jn(e,o),Object.defineProperty(e,"prototype",{writable:!1}),n}();SS=new WeakSet,OS=function(){var t=this,e=n("svg"),r=Ab(this.calendar.options.options.scale),o=this.options,i=o.width,a=o.height,u=o.gutter,c=o.includeBlank,s=Zn(r.range);return c&&s.unshift(null),e.attr("class",".ch-container".slice(1)).attr("width",s.length*i+(s.length-1)*u).attr("height",a),e.selectAll("rect").data(s).join((function(n){return n.append("rect").call((function(n){return og(t,SS,"m",jS).call(t,n,r)}))}),(function(n){return n.selectAll("rect").call((function(n){return og(t,SS,"m",jS).call(t,n,r)}))})),e},jS=function(t,n){var e=this,r=this.options,o=r.width,i=r.height,a=r.radius,u=r.gutter;return t.attr("width",o).attr("height",i).attr("class","".concat(".ch-subdomain".slice(1),"-bg")).attr("rx",a).attr("ry",a).attr("x",(function(t,n){return n*(o+u)})).attr("y",0).call((function(t){Mb(t,n,e.calendar.options.options.scale)}))};export{xS as default};//# sourceMappingURL=LegendLite.min.esm.js.map diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.esm.js.map b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.esm.js.map new file mode 100644 index 0000000..309db53 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.esm.js.map @@ -0,0 +1 @@ +{"version":3,"file":"LegendLite.min.esm.js","sources":["../../node_modules/core-js/internals/fails.js","../../node_modules/core-js/internals/descriptors.js","../../node_modules/core-js/internals/function-bind-native.js","../../node_modules/core-js/internals/function-uncurry-this.js","../../node_modules/core-js/internals/is-null-or-undefined.js","../../node_modules/core-js/internals/require-object-coercible.js","../../node_modules/core-js/internals/to-object.js","../../node_modules/core-js/internals/has-own-property.js","../../node_modules/core-js/internals/function-name.js","../../node_modules/core-js/internals/document-all.js","../../node_modules/core-js/internals/is-callable.js","../../node_modules/core-js/internals/global.js","../../node_modules/core-js/internals/define-global-property.js","../../node_modules/core-js/internals/shared-store.js","../../node_modules/core-js/internals/inspect-source.js","../../node_modules/core-js/internals/engine-v8-version.js","../../node_modules/core-js/internals/weak-map-basic-detection.js","../../node_modules/core-js/internals/is-object.js","../../node_modules/core-js/internals/document-create-element.js","../../node_modules/core-js/internals/ie8-dom-define.js","../../node_modules/core-js/internals/v8-prototype-define-bug.js","../../node_modules/core-js/internals/an-object.js","../../node_modules/core-js/internals/function-call.js","../../node_modules/core-js/internals/get-built-in.js","../../node_modules/core-js/internals/object-is-prototype-of.js","../../node_modules/core-js/internals/engine-user-agent.js","../../node_modules/core-js/internals/symbol-constructor-detection.js","../../node_modules/core-js/internals/use-symbol-as-uid.js","../../node_modules/core-js/internals/is-symbol.js","../../node_modules/core-js/internals/try-to-string.js","../../node_modules/core-js/internals/a-callable.js","../../node_modules/core-js/internals/get-method.js","../../node_modules/core-js/internals/ordinary-to-primitive.js","../../node_modules/core-js/internals/shared.js","../../node_modules/core-js/internals/uid.js","../../node_modules/core-js/internals/well-known-symbol.js","../../node_modules/core-js/internals/to-primitive.js","../../node_modules/core-js/internals/to-property-key.js","../../node_modules/core-js/internals/object-define-property.js","../../node_modules/core-js/internals/create-property-descriptor.js","../../node_modules/core-js/internals/internal-state.js","../../node_modules/core-js/internals/create-non-enumerable-property.js","../../node_modules/core-js/internals/shared-key.js","../../node_modules/core-js/internals/hidden-keys.js","../../node_modules/core-js/internals/make-built-in.js","../../node_modules/core-js/internals/define-built-in-accessor.js","../../node_modules/core-js/modules/es.function.name.js","../../node_modules/core-js/internals/object-property-is-enumerable.js","../../node_modules/core-js/internals/classof-raw.js","../../node_modules/core-js/internals/indexed-object.js","../../node_modules/core-js/internals/to-indexed-object.js","../../node_modules/core-js/internals/object-get-own-property-descriptor.js","../../node_modules/core-js/internals/define-built-in.js","../../node_modules/core-js/internals/math-trunc.js","../../node_modules/core-js/internals/to-integer-or-infinity.js","../../node_modules/core-js/internals/to-absolute-index.js","../../node_modules/core-js/internals/to-length.js","../../node_modules/core-js/internals/length-of-array-like.js","../../node_modules/core-js/internals/array-includes.js","../../node_modules/core-js/internals/object-keys-internal.js","../../node_modules/core-js/internals/enum-bug-keys.js","../../node_modules/core-js/internals/object-get-own-property-names.js","../../node_modules/core-js/internals/object-get-own-property-symbols.js","../../node_modules/core-js/internals/own-keys.js","../../node_modules/core-js/internals/copy-constructor-properties.js","../../node_modules/core-js/internals/is-forced.js","../../node_modules/core-js/internals/export.js","../../node_modules/core-js/internals/object-keys.js","../../node_modules/core-js/internals/object-assign.js","../../node_modules/core-js/modules/es.object.assign.js","../../node_modules/core-js/internals/to-string-tag-support.js","../../node_modules/core-js/internals/classof.js","../../node_modules/core-js/internals/object-to-string.js","../../node_modules/core-js/modules/es.object.to-string.js","../../node_modules/core-js/internals/engine-is-node.js","../../node_modules/core-js/internals/function-uncurry-this-accessor.js","../../node_modules/core-js/internals/a-possible-prototype.js","../../node_modules/core-js/internals/object-set-prototype-of.js","../../node_modules/core-js/internals/set-to-string-tag.js","../../node_modules/core-js/internals/set-species.js","../../node_modules/core-js/internals/an-instance.js","../../node_modules/core-js/internals/is-constructor.js","../../node_modules/core-js/internals/task.js","../../node_modules/core-js/internals/a-constructor.js","../../node_modules/core-js/internals/species-constructor.js","../../node_modules/core-js/internals/function-apply.js","../../node_modules/core-js/internals/function-uncurry-this-clause.js","../../node_modules/core-js/internals/function-bind-context.js","../../node_modules/core-js/internals/html.js","../../node_modules/core-js/internals/array-slice.js","../../node_modules/core-js/internals/validate-arguments-length.js","../../node_modules/core-js/internals/engine-is-ios.js","../../node_modules/core-js/internals/queue.js","../../node_modules/core-js/internals/microtask.js","../../node_modules/core-js/internals/engine-is-ios-pebble.js","../../node_modules/core-js/internals/engine-is-webos-webkit.js","../../node_modules/core-js/internals/perform.js","../../node_modules/core-js/internals/promise-native-constructor.js","../../node_modules/core-js/internals/engine-is-deno.js","../../node_modules/core-js/internals/engine-is-browser.js","../../node_modules/core-js/internals/promise-constructor-detection.js","../../node_modules/core-js/internals/new-promise-capability.js","../../node_modules/core-js/modules/es.promise.constructor.js","../../node_modules/core-js/internals/host-report-errors.js","../../node_modules/core-js/internals/iterators.js","../../node_modules/core-js/internals/is-array-iterator-method.js","../../node_modules/core-js/internals/get-iterator-method.js","../../node_modules/core-js/internals/get-iterator.js","../../node_modules/core-js/internals/iterator-close.js","../../node_modules/core-js/internals/iterate.js","../../node_modules/core-js/internals/check-correctness-of-iteration.js","../../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","../../node_modules/core-js/modules/es.promise.all.js","../../node_modules/core-js/modules/es.promise.catch.js","../../node_modules/core-js/modules/es.promise.race.js","../../node_modules/core-js/modules/es.promise.reject.js","../../node_modules/core-js/internals/promise-resolve.js","../../node_modules/core-js/modules/es.promise.resolve.js","../../node_modules/core-js/internals/object-define-properties.js","../../node_modules/core-js/internals/object-create.js","../../node_modules/core-js/internals/add-to-unscopables.js","../../node_modules/core-js/internals/iterators-core.js","../../node_modules/core-js/internals/correct-prototype-getter.js","../../node_modules/core-js/internals/object-get-prototype-of.js","../../node_modules/core-js/internals/iterator-create-constructor.js","../../node_modules/core-js/internals/iterator-define.js","../../node_modules/core-js/internals/create-iter-result-object.js","../../node_modules/core-js/modules/es.array.iterator.js","../../node_modules/core-js/internals/to-string.js","../../node_modules/core-js/internals/string-multibyte.js","../../node_modules/core-js/modules/es.string.iterator.js","../../node_modules/core-js/internals/create-property.js","../../node_modules/core-js/internals/array-slice-simple.js","../../node_modules/core-js/internals/object-get-own-property-names-external.js","../../node_modules/core-js/internals/array-buffer-non-extensible.js","../../node_modules/core-js/internals/object-is-extensible.js","../../node_modules/core-js/internals/freezing.js","../../node_modules/core-js/internals/internal-metadata.js","../../node_modules/core-js/internals/inherit-if-required.js","../../node_modules/core-js/internals/collection.js","../../node_modules/core-js/internals/define-built-ins.js","../../node_modules/core-js/internals/is-array.js","../../node_modules/core-js/internals/array-species-constructor.js","../../node_modules/core-js/internals/array-species-create.js","../../node_modules/core-js/internals/array-iteration.js","../../node_modules/core-js/internals/collection-weak.js","../../node_modules/core-js/modules/es.weak-set.constructor.js","../../node_modules/core-js/internals/dom-iterables.js","../../node_modules/core-js/internals/dom-token-list-prototype.js","../../node_modules/core-js/modules/web.dom-collections.iterator.js","../../node_modules/core-js/internals/array-method-has-species-support.js","../../node_modules/core-js/modules/es.array.slice.js","../../node_modules/core-js/internals/array-method-is-strict.js","../../node_modules/core-js/modules/es.array.join.js","../../node_modules/tslib/tslib.es6.js","../../node_modules/core-js/modules/es.object.keys.js","../../node_modules/core-js/internals/is-regexp.js","../../node_modules/core-js/modules/es.string.starts-with.js","../../node_modules/core-js/internals/not-a-regexp.js","../../node_modules/core-js/internals/correct-is-regexp-logic.js","../../node_modules/core-js/internals/array-for-each.js","../../node_modules/core-js/modules/web.dom-collections.for-each.js","../../node_modules/core-js/internals/object-to-array.js","../../node_modules/core-js/modules/es.object.entries.js","../../node_modules/@observablehq/plot/src/defined.js","../../node_modules/isoformat/src/parse.js","../../node_modules/@observablehq/plot/src/time.js","../../node_modules/@observablehq/plot/src/options.js","../../node_modules/@observablehq/plot/src/scales/index.js","../../node_modules/@observablehq/plot/src/symbol.js","../../node_modules/@observablehq/plot/src/warnings.js","../../node_modules/@observablehq/plot/src/scales/schemes.js","../../node_modules/@observablehq/plot/src/scales/quantitative.js","../../node_modules/@observablehq/plot/src/scales/diverging.js","../../node_modules/@observablehq/plot/src/scales/temporal.js","../../node_modules/@observablehq/plot/src/scales/ordinal.js","../../node_modules/@observablehq/plot/src/scales.js","../../../src/constant.ts","../../../src/scale.ts","../../node_modules/core-js/internals/does-not-exceed-safe-integer.js","../../node_modules/core-js/modules/es.array.concat.js","../../node_modules/core-js/modules/es.promise.all-settled.js","../../node_modules/core-js/internals/collection-strong.js","../../node_modules/core-js/modules/es.map.constructor.js","../../node_modules/core-js/internals/delete-property-or-throw.js","../../node_modules/core-js/internals/array-sort.js","../../node_modules/core-js/internals/engine-ff-version.js","../../node_modules/core-js/internals/engine-is-ie-or-edge.js","../../node_modules/core-js/internals/engine-webkit-version.js","../../node_modules/core-js/modules/es.array.sort.js","../../node_modules/core-js/modules/es.array.includes.js","../../node_modules/core-js/modules/es.array.map.js","../../node_modules/core-js/modules/es.array.filter.js","../../node_modules/core-js/internals/call-with-safe-iteration-closing.js","../../node_modules/core-js/internals/array-from.js","../../node_modules/core-js/modules/es.array.from.js","../../node_modules/core-js/internals/whitespaces.js","../../node_modules/core-js/internals/string-trim.js","../../node_modules/core-js/internals/string-trim-forced.js","../../node_modules/core-js/modules/es.string.trim.js","../../../src/subDomain/SubDomainPainter.ts","../../../src/plugins/LegendLite.ts","../../../src/calendar/CalendarPainter.ts"],"sourcesContent":["'use strict';\nmodule.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-function-prototype-bind -- safe\n var test = (function () { /* empty */ }).bind();\n // eslint-disable-next-line no-prototype-builtins -- safe\n return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n return function () {\n return call.apply(fn, arguments);\n };\n};\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n return it === null || it === undefined;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n return it;\n};\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar documentAll = typeof document == 'object' && document.all;\n\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nvar IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;\n\nmodule.exports = {\n all: documentAll,\n IS_HTMLDDA: IS_HTMLDDA\n};\n","'use strict';\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = $documentAll.IS_HTMLDDA ? function (argument) {\n return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n return typeof argument == 'function';\n};\n","'use strict';\nvar check = function (it) {\n return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n check(typeof this == 'object' && this) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\nmodule.exports = $documentAll.IS_HTMLDDA ? function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;\n} : function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a !== 7;\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype !== 42;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol('symbol detection');\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n // of course, fail.\n return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n try {\n return $String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.34.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',\n license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',\n source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name)) {\n WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n ? Symbol[name]\n : createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw new $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","'use strict';\nmodule.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n /* eslint-disable no-self-assign -- prototype methods protection */\n store.get = store.get;\n store.has = store.has;\n store.set = store.set;\n /* eslint-enable no-self-assign -- prototype methods protection */\n set = function (it, metadata) {\n if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n store.set(it, metadata);\n return metadata;\n };\n get = function (it) {\n return store.get(it) || {};\n };\n has = function (it) {\n return store.has(it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (options && options.getter) name = 'get ' + name;\n if (options && options.setter) name = 'set ' + name;\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n else value.name = name;\n }\n if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n defineProperty(value, 'length', { value: options.arity });\n }\n try {\n if (options && hasOwn(options, 'constructor') && options.constructor) {\n if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n } else if (value.prototype) value.prototype = undefined;\n } catch (error) { /* empty */ }\n var state = enforceInternalState(value);\n if (!hasOwn(state, 'source')) {\n state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineProperty = require('../internals/object-define-property');\n\nmodule.exports = function (target, name, descriptor) {\n if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });\n if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });\n return defineProperty.f(target, name, descriptor);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar FUNCTION_NAME_EXISTS = require('../internals/function-name').EXISTS;\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\n\nvar FunctionPrototype = Function.prototype;\nvar functionToString = uncurryThis(FunctionPrototype.toString);\nvar nameRE = /function\\b(?:\\s|\\/\\*[\\S\\s]*?\\*\\/|\\/\\/[^\\n\\r]*[\\n\\r]+)*([^\\s(/]*)/;\nvar regExpExec = uncurryThis(nameRE.exec);\nvar NAME = 'name';\n\n// Function instances `.name` property\n// https://tc39.es/ecma262/#sec-function-instances-name\nif (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {\n defineBuiltInAccessor(FunctionPrototype, NAME, {\n configurable: true,\n get: function () {\n try {\n return regExpExec(nameRE, functionToString(this))[1];\n } catch (error) {\n return '';\n }\n }\n });\n}\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- NaN check\n return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el !== el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value !== value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value === POLYFILL ? true\n : value === NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.dontCallGetSet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || defineGlobalProperty(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.dontCallGetSet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n defineBuiltIn(target, key, sourceProperty, options);\n }\n};\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol('assign detection');\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","'use strict';\nvar $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {\n assign: assign\n});\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar global = require('../internals/global');\nvar classof = require('../internals/classof-raw');\n\nmodule.exports = classof(global.process) === 'process';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nmodule.exports = function (object, key, method) {\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));\n } catch (error) { /* empty */ }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw new $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","'use strict';\n/* eslint-disable no-proto -- safe */\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (target, TAG, STATIC) {\n if (target && !STATIC) target = target.prototype;\n if (target && !hasOwn(target, TO_STRING_TAG)) {\n defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineBuiltInAccessor(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw new $TypeError('Incorrect invocation');\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.test(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n }\n try {\n // we can't check .prototype since constructors produced by .bind haven't it\n // `Function#toString` throws on some built-it function in some legacy engines\n // (for example, `DOMQuad` and similar in FF41-)\n return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n } catch (error) {\n return true;\n }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar $location, defer, channel, port;\n\nfails(function () {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n $location = global.location;\n});\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar eventListener = function (event) {\n run(event.data);\n};\n\nvar globalPostMessageDefer = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), $location.protocol + '//' + $location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(handler) {\n validateArgumentsLength(arguments.length, 1);\n var fn = isCallable(handler) ? handler : Function(handler);\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(fn, undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = eventListener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n $location && $location.protocol !== 'file:' &&\n !fails(globalPostMessageDefer)\n ) {\n defer = globalPostMessageDefer;\n global.addEventListener('message', eventListener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","'use strict';\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a constructor');\n};\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","'use strict';\nvar classofRaw = require('../internals/classof-raw');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (fn) {\n // Nashorn bug:\n // https://github.com/zloirock/core-js/issues/1128\n // https://github.com/zloirock/core-js/issues/1130\n if (classofRaw(fn) === 'Function') return uncurryThis(fn);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","'use strict';\nvar $TypeError = TypeError;\n\nmodule.exports = function (passed, required) {\n if (passed < required) throw new $TypeError('Not enough arguments');\n return passed;\n};\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line redos/no-vulnerable -- safe\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","'use strict';\nvar Queue = function () {\n this.head = null;\n this.tail = null;\n};\n\nQueue.prototype = {\n add: function (item) {\n var entry = { item: item, next: null };\n var tail = this.tail;\n if (tail) tail.next = entry;\n else this.head = entry;\n this.tail = entry;\n },\n get: function () {\n var entry = this.head;\n if (entry) {\n var next = this.head = entry.next;\n if (next === null) this.tail = null;\n return entry.item;\n }\n }\n};\n\nmodule.exports = Queue;\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar Queue = require('../internals/queue');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar microtask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\nvar notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!microtask) {\n var queue = new Queue();\n\n var flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (fn = queue.get()) try {\n fn();\n } catch (error) {\n if (queue.head) notify();\n throw error;\n }\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessage\n // - onreadystatechange\n // - setTimeout\n } else {\n // `webpack` dev server bug on IE global methods - use bind(fn, global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n\n microtask = function (fn) {\n if (!queue.head) notify();\n queue.add(fn);\n };\n}\n\nmodule.exports = microtask;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","'use strict';\nvar global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n && typeof window == 'object'\n && typeof document == 'object';\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n // Detect correctness of subclassing with @@species support\n var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar $TypeError = TypeError;\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar IS_NODE = require('../internals/engine-is-node');\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar perform = require('../internals/perform');\nvar Queue = require('../internals/queue');\nvar InternalStateModule = require('../internals/internal-state');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar PromiseConstructorDetection = require('../internals/promise-constructor-detection');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\n\nvar PROMISE = 'Promise';\nvar FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;\nvar NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;\nvar NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar PromiseConstructor = NativePromiseConstructor;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar callReaction = function (reaction, state) {\n var value = state.value;\n var ok = state.state === FULFILLED;\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(new TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n microtask(function () {\n var reactions = state.reactions;\n var reaction;\n while (reaction = reactions.get()) {\n callReaction(reaction, state);\n }\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw new TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED_PROMISE_CONSTRUCTOR) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalPromiseState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n\n PromisePrototype = PromiseConstructor.prototype;\n\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: new Queue(),\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n state.parent = true;\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n if (state.state === PENDING) state.reactions.add(reaction);\n else microtask(function () {\n callReaction(reaction, state);\n });\n return reaction.promise;\n });\n\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalPromiseState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!NATIVE_PROMISE_SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n","'use strict';\nmodule.exports = function (a, b) {\n try {\n // eslint-disable-next-line no-console -- safe\n arguments.length === 1 ? console.error(a) : console.error(a, b);\n } catch (error) { /* empty */ }\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw new $TypeError(tryToString(argument) + ' is not iterable');\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_RECORD = !!(options && options.IS_RECORD);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_RECORD) {\n iterator = iterable.iterator;\n } else if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = IS_RECORD ? iterable.next : iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n try {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n } catch (error) { return false; } // workaround of old WebKit + `eval` bug\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.all` method\n// https://tc39.es/ecma262/#sec-promise.all\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar defineBuiltIn = require('../internals/define-built-in');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\n\n// `Promise.prototype.catch` method\n// https://tc39.es/ecma262/#sec-promise.prototype.catch\n$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n});\n\n// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromiseConstructor)) {\n var method = getBuiltIn('Promise').prototype['catch'];\n if (NativePromisePrototype['catch'] !== method) {\n defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.race` method\n// https://tc39.es/ecma262/#sec-promise.race\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\n// `Promise.reject` method\n// https://tc39.es/ecma262/#sec-promise.reject\n$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n reject: function reject(r) {\n var capability = newPromiseCapabilityModule.f(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar promiseResolve = require('../internals/promise-resolve');\n\nvar PromiseConstructorWrapper = getBuiltIn('Promise');\nvar CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;\n\n// `Promise.resolve` method\n// https://tc39.es/ecma262/#sec-promise.resolve\n$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {\n resolve: function resolve(x) {\n return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);\n }\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var props = toIndexedObject(Properties);\n var keys = objectKeys(Properties);\n var length = keys.length;\n var index = 0;\n var key;\n while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n return O;\n};\n","'use strict';\n/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n activeXDocument.write(scriptTag(''));\n activeXDocument.close();\n var temp = activeXDocument.parentWindow.Object;\n activeXDocument = null; // avoid memory leak\n return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = documentCreateElement('iframe');\n var JS = 'java' + SCRIPT + ':';\n var iframeDocument;\n iframe.style.display = 'none';\n html.appendChild(iframe);\n // https://github.com/zloirock/core-js/issues/475\n iframe.src = String(JS);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(scriptTag('document.F=Object'));\n iframeDocument.close();\n return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n try {\n activeXDocument = new ActiveXObject('htmlfile');\n } catch (error) { /* ignore */ }\n NullProtoObject = typeof document != 'undefined'\n ? document.domain && activeXDocument\n ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n : NullProtoObjectViaIFrame()\n : NullProtoObjectViaActiveX(activeXDocument); // WSH\n var length = enumBugKeys.length;\n while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n EmptyConstructor[PROTOTYPE] = anObject(O);\n result = new EmptyConstructor();\n EmptyConstructor[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = NullProtoObject();\n return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] === undefined) {\n defineProperty(ArrayPrototype, UNSCOPABLES, {\n configurable: true,\n value: create(null)\n });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n arrayIterator = [].keys();\n // Safari 8 has buggy iterators w/o `next`\n if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n else {\n PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {\n var test = {};\n // FF44- legacy iterators case\n return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n defineBuiltIn(IteratorPrototype, ITERATOR, function () {\n return this;\n });\n}\n\nmodule.exports = {\n IteratorPrototype: IteratorPrototype,\n BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n function F() { /* empty */ }\n F.prototype.constructor = null;\n // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar $Object = Object;\nvar ObjectPrototype = $Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n// eslint-disable-next-line es/no-object-getprototypeof -- safe\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {\n var object = toObject(O);\n if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n var constructor = object.constructor;\n if (isCallable(constructor) && object instanceof constructor) {\n return constructor.prototype;\n } return object instanceof $Object ? ObjectPrototype : null;\n};\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {\n var TO_STRING_TAG = NAME + ' Iterator';\n IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });\n setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n Iterators[TO_STRING_TAG] = returnThis;\n return IteratorConstructor;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/iterator-create-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n createIteratorConstructor(IteratorConstructor, NAME, next);\n\n var getIterationMethod = function (KIND) {\n if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];\n\n switch (KIND) {\n case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n }\n\n return function () { return new IteratorConstructor(this); };\n };\n\n var TO_STRING_TAG = NAME + ' Iterator';\n var INCORRECT_VALUES_NAME = false;\n var IterablePrototype = Iterable.prototype;\n var nativeIterator = IterablePrototype[ITERATOR]\n || IterablePrototype['@@iterator']\n || DEFAULT && IterablePrototype[DEFAULT];\n var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n var CurrentIteratorPrototype, methods, KEY;\n\n // fix native\n if (anyNativeIterator) {\n CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n if (setPrototypeOf) {\n setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);\n }\n }\n // Set @@toStringTag to native iterators\n setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n }\n }\n\n // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n } else {\n INCORRECT_VALUES_NAME = true;\n defaultIterator = function values() { return call(nativeIterator, this); };\n }\n }\n\n // export additional methods\n if (DEFAULT) {\n methods = {\n values: getIterationMethod(VALUES),\n keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n entries: getIterationMethod(ENTRIES)\n };\n if (FORCED) for (KEY in methods) {\n if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n defineBuiltIn(IterablePrototype, KEY, methods[KEY]);\n }\n } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n }\n\n // define iterator\n if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n }\n Iterators[NAME] = defaultIterator;\n\n return methods;\n};\n","'use strict';\n// `CreateIterResultObject` abstract operation\n// https://tc39.es/ecma262/#sec-createiterresultobject\nmodule.exports = function (value, done) {\n return { value: value, done: done };\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineProperty = require('../internals/object-define-property').f;\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar IS_PURE = require('../internals/is-pure');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n setInternalState(this, {\n type: ARRAY_ITERATOR,\n target: toIndexedObject(iterated), // target\n index: 0, // next index\n kind: kind // kind\n });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n var state = getInternalState(this);\n var target = state.target;\n var index = state.index++;\n if (!target || index >= target.length) {\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n switch (state.kind) {\n case 'keys': return createIterResultObject(index, false);\n case 'values': return createIterResultObject(target[index], false);\n } return createIterResultObject([index, target[index]], false);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nvar values = Iterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n// V8 ~ Chrome 45- bug\nif (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {\n defineProperty(values, 'name', { value: 'values' });\n} catch (error) { /* empty */ }\n","'use strict';\nvar classof = require('../internals/classof');\n\nvar $String = String;\n\nmodule.exports = function (argument) {\n if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n return $String(argument);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n return function ($this, pos) {\n var S = toString(requireObjectCoercible($this));\n var position = toIntegerOrInfinity(pos);\n var size = S.length;\n var first, second;\n if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n first = charCodeAt(S, position);\n return first < 0xD800 || first > 0xDBFF || position + 1 === size\n || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n ? CONVERT_TO_STRING\n ? charAt(S, position)\n : first\n : CONVERT_TO_STRING\n ? stringSlice(S, position, position + 2)\n : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n };\n};\n\nmodule.exports = {\n // `String.prototype.codePointAt` method\n // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n codeAt: createMethod(false),\n // `String.prototype.at` method\n // https://github.com/mathiasbynens/String.prototype.at\n charAt: createMethod(true)\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n setInternalState(this, {\n type: STRING_ITERATOR,\n string: toString(iterated),\n index: 0\n });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n var state = getInternalState(this);\n var string = state.string;\n var index = state.index;\n var point;\n if (index >= string.length) return createIterResultObject(undefined, true);\n point = charAt(string, index);\n state.index += point.length;\n return createIterResultObject(point, false);\n});\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n var propertyKey = toPropertyKey(key);\n if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n else object[propertyKey] = value;\n};\n","'use strict';\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\n\nvar $Array = Array;\nvar max = Math.max;\n\nmodule.exports = function (O, start, end) {\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n var result = $Array(max(fin - k, 0));\n var n = 0;\n for (; k < fin; k++, n++) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n};\n","'use strict';\n/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n try {\n return $getOwnPropertyNames(it);\n } catch (error) {\n return arraySlice(windowNames);\n }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n return windowNames && classof(it) === 'Window'\n ? getWindowNames(it)\n : $getOwnPropertyNames(toIndexedObject(it));\n};\n","'use strict';\n// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it\nvar fails = require('../internals/fails');\n\nmodule.exports = fails(function () {\n if (typeof ArrayBuffer == 'function') {\n var buffer = new ArrayBuffer(8);\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe\n if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar ARRAY_BUFFER_NON_EXTENSIBLE = require('../internals/array-buffer-non-extensible');\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar $isExtensible = Object.isExtensible;\nvar FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); });\n\n// `Object.isExtensible` method\n// https://tc39.es/ecma262/#sec-object.isextensible\nmodule.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) {\n if (!isObject(it)) return false;\n if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false;\n return $isExtensible ? $isExtensible(it) : true;\n} : $isExtensible;\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n return Object.isExtensible(Object.preventExtensions({}));\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar isExtensible = require('../internals/object-is-extensible');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar setMetadata = function (it) {\n defineProperty(it, METADATA, { value: {\n objectID: 'O' + id++, // object ID\n weakData: {} // weak collections IDs\n } });\n};\n\nvar fastKey = function (it, create) {\n // return a primitive with prefix\n if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return 'F';\n // not necessary to add metadata\n if (!create) return 'E';\n // add missing metadata\n setMetadata(it);\n // return object ID\n } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return true;\n // not necessary to add metadata\n if (!create) return false;\n // add missing metadata\n setMetadata(it);\n // return the store of weak collections IDs\n } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n return it;\n};\n\nvar enable = function () {\n meta.enable = function () { /* empty */ };\n REQUIRED = true;\n var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n var splice = uncurryThis([].splice);\n var test = {};\n test[METADATA] = 1;\n\n // prevent exposing of metadata key\n if (getOwnPropertyNames(test).length) {\n getOwnPropertyNamesModule.f = function (it) {\n var result = getOwnPropertyNames(it);\n for (var i = 0, length = result.length; i < length; i++) {\n if (result[i] === METADATA) {\n splice(result, i, 1);\n break;\n }\n } return result;\n };\n\n $({ target: 'Object', stat: true, forced: true }, {\n getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n });\n }\n};\n\nvar meta = module.exports = {\n enable: enable,\n fastKey: fastKey,\n getWeakData: getWeakData,\n onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n var NewTarget, NewTargetPrototype;\n if (\n // it can work only with native `setPrototypeOf`\n setPrototypeOf &&\n // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n isCallable(NewTarget = dummy.constructor) &&\n NewTarget !== Wrapper &&\n isObject(NewTargetPrototype = NewTarget.prototype) &&\n NewTargetPrototype !== Wrapper.prototype\n ) setPrototypeOf($this, NewTargetPrototype);\n return $this;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n var ADDER = IS_MAP ? 'set' : 'add';\n var NativeConstructor = global[CONSTRUCTOR_NAME];\n var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n var Constructor = NativeConstructor;\n var exported = {};\n\n var fixMethod = function (KEY) {\n var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n defineBuiltIn(NativePrototype, KEY,\n KEY === 'add' ? function add(value) {\n uncurriedNativeMethod(this, value === 0 ? 0 : value);\n return this;\n } : KEY === 'delete' ? function (key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'get' ? function get(key) {\n return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'has' ? function has(key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : function set(key, value) {\n uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n return this;\n }\n );\n };\n\n var REPLACE = isForced(\n CONSTRUCTOR_NAME,\n !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n new NativeConstructor().entries().next();\n }))\n );\n\n if (REPLACE) {\n // create collection constructor\n Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n InternalMetadataModule.enable();\n } else if (isForced(CONSTRUCTOR_NAME, true)) {\n var instance = new Constructor();\n // early implementations not supports chaining\n var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance;\n // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n // most early implementations doesn't supports iterables, most modern - not close it correctly\n // eslint-disable-next-line no-new -- required for testing\n var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n // for early implementations -0 and +0 not the same\n var BUGGY_ZERO = !IS_WEAK && fails(function () {\n // V8 ~ Chromium 42- fails only with 5+ elements\n var $instance = new NativeConstructor();\n var index = 5;\n while (index--) $instance[ADDER](index, index);\n return !$instance.has(-0);\n });\n\n if (!ACCEPT_ITERABLES) {\n Constructor = wrapper(function (dummy, iterable) {\n anInstance(dummy, NativePrototype);\n var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n return that;\n });\n Constructor.prototype = NativePrototype;\n NativePrototype.constructor = Constructor;\n }\n\n if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n fixMethod('delete');\n fixMethod('has');\n IS_MAP && fixMethod('get');\n }\n\n if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n // weak collections should not contains .clear method\n if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n }\n\n exported[CONSTRUCTOR_NAME] = Constructor;\n $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported);\n\n setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n return Constructor;\n};\n","'use strict';\nvar defineBuiltIn = require('../internals/define-built-in');\n\nmodule.exports = function (target, src, options) {\n for (var key in src) defineBuiltIn(target, key, src[key], options);\n return target;\n};\n","'use strict';\nvar classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n return classof(argument) === 'Array';\n};\n","'use strict';\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n var C;\n if (isArray(originalArray)) {\n C = originalArray.constructor;\n // cross-realm fallback\n if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;\n else if (isObject(C)) {\n C = C[SPECIES];\n if (C === null) C = undefined;\n }\n } return C === undefined ? $Array : C;\n};\n","'use strict';\nvar arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n var IS_MAP = TYPE === 1;\n var IS_FILTER = TYPE === 2;\n var IS_SOME = TYPE === 3;\n var IS_EVERY = TYPE === 4;\n var IS_FIND_INDEX = TYPE === 6;\n var IS_FILTER_REJECT = TYPE === 7;\n var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;\n return function ($this, callbackfn, that, specificCreate) {\n var O = toObject($this);\n var self = IndexedObject(O);\n var length = lengthOfArrayLike(self);\n var boundFunction = bind(callbackfn, that);\n var index = 0;\n var create = specificCreate || arraySpeciesCreate;\n var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n var value, result;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n value = self[index];\n result = boundFunction(value, index, O);\n if (TYPE) {\n if (IS_MAP) target[index] = result; // map\n else if (result) switch (TYPE) {\n case 3: return true; // some\n case 5: return value; // find\n case 6: return index; // findIndex\n case 2: push(target, value); // filter\n } else switch (TYPE) {\n case 4: return false; // every\n case 7: push(target, value); // filterReject\n }\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.forEach` method\n // https://tc39.es/ecma262/#sec-array.prototype.foreach\n forEach: createMethod(0),\n // `Array.prototype.map` method\n // https://tc39.es/ecma262/#sec-array.prototype.map\n map: createMethod(1),\n // `Array.prototype.filter` method\n // https://tc39.es/ecma262/#sec-array.prototype.filter\n filter: createMethod(2),\n // `Array.prototype.some` method\n // https://tc39.es/ecma262/#sec-array.prototype.some\n some: createMethod(3),\n // `Array.prototype.every` method\n // https://tc39.es/ecma262/#sec-array.prototype.every\n every: createMethod(4),\n // `Array.prototype.find` method\n // https://tc39.es/ecma262/#sec-array.prototype.find\n find: createMethod(5),\n // `Array.prototype.findIndex` method\n // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n findIndex: createMethod(6),\n // `Array.prototype.filterReject` method\n // https://github.com/tc39/proposal-array-filtering\n filterReject: createMethod(7)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar getWeakData = require('../internals/internal-metadata').getWeakData;\nvar anInstance = require('../internals/an-instance');\nvar anObject = require('../internals/an-object');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar iterate = require('../internals/iterate');\nvar ArrayIterationModule = require('../internals/array-iteration');\nvar hasOwn = require('../internals/has-own-property');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\nvar find = ArrayIterationModule.find;\nvar findIndex = ArrayIterationModule.findIndex;\nvar splice = uncurryThis([].splice);\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (state) {\n return state.frozen || (state.frozen = new UncaughtFrozenStore());\n};\n\nvar UncaughtFrozenStore = function () {\n this.entries = [];\n};\n\nvar findUncaughtFrozen = function (store, key) {\n return find(store.entries, function (it) {\n return it[0] === key;\n });\n};\n\nUncaughtFrozenStore.prototype = {\n get: function (key) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) return entry[1];\n },\n has: function (key) {\n return !!findUncaughtFrozen(this, key);\n },\n set: function (key, value) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) entry[1] = value;\n else this.entries.push([key, value]);\n },\n 'delete': function (key) {\n var index = findIndex(this.entries, function (it) {\n return it[0] === key;\n });\n if (~index) splice(this.entries, index, 1);\n return !!~index;\n }\n};\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n id: id++,\n frozen: undefined\n });\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var data = getWeakData(anObject(key), true);\n if (data === true) uncaughtFrozenStore(state).set(key, value);\n else data[state.id] = value;\n return that;\n };\n\n defineBuiltIns(Prototype, {\n // `{ WeakMap, WeakSet }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.delete\n // https://tc39.es/ecma262/#sec-weakset.prototype.delete\n 'delete': function (key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state)['delete'](key);\n return data && hasOwn(data, state.id) && delete data[state.id];\n },\n // `{ WeakMap, WeakSet }.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.has\n // https://tc39.es/ecma262/#sec-weakset.prototype.has\n has: function has(key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).has(key);\n return data && hasOwn(data, state.id);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `WeakMap.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.get\n get: function get(key) {\n var state = getInternalState(this);\n if (isObject(key)) {\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).get(key);\n return data ? data[state.id] : undefined;\n }\n },\n // `WeakMap.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.set\n set: function set(key, value) {\n return define(this, key, value);\n }\n } : {\n // `WeakSet.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-weakset.prototype.add\n add: function add(value) {\n return define(this, value, true);\n }\n });\n\n return Constructor;\n }\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionWeak = require('../internals/collection-weak');\n\n// `WeakSet` constructor\n// https://tc39.es/ecma262/#sec-weakset-constructor\ncollection('WeakSet', function (init) {\n return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionWeak);\n","'use strict';\n// iterable DOM collections\n// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods\nmodule.exports = {\n CSSRuleList: 0,\n CSSStyleDeclaration: 0,\n CSSValueList: 0,\n ClientRectList: 0,\n DOMRectList: 0,\n DOMStringList: 0,\n DOMTokenList: 1,\n DataTransferItemList: 0,\n FileList: 0,\n HTMLAllCollection: 0,\n HTMLCollection: 0,\n HTMLFormElement: 0,\n HTMLSelectElement: 0,\n MediaList: 0,\n MimeTypeArray: 0,\n NamedNodeMap: 0,\n NodeList: 1,\n PaintRequestList: 0,\n Plugin: 0,\n PluginArray: 0,\n SVGLengthList: 0,\n SVGNumberList: 0,\n SVGPathSegList: 0,\n SVGPointList: 0,\n SVGStringList: 0,\n SVGTransformList: 0,\n SourceBufferList: 0,\n StyleSheetList: 0,\n TextTrackCueList: 0,\n TextTrackList: 0,\n TouchList: 0\n};\n","'use strict';\n// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`\nvar documentCreateElement = require('../internals/document-create-element');\n\nvar classList = documentCreateElement('span').classList;\nvar DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;\n\nmodule.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nvar handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {\n if (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n } catch (error) {\n CollectionPrototype[ITERATOR] = ArrayValues;\n }\n setToStringTag(CollectionPrototype, COLLECTION_NAME, true);\n if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n } catch (error) {\n CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n }\n }\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);\n}\n\nhandlePrototype(DOMTokenListPrototype, 'DOMTokenList');\n","'use strict';\nvar fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (METHOD_NAME) {\n // We can't use this feature detection in V8 since it causes\n // deoptimization and serious performance degradation\n // https://github.com/zloirock/core-js/issues/677\n return V8_VERSION >= 51 || !fails(function () {\n var array = [];\n var constructor = array.constructor = {};\n constructor[SPECIES] = function () {\n return { foo: 1 };\n };\n return array[METHOD_NAME](Boolean).foo !== 1;\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar createProperty = require('../internals/create-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar nativeSlice = require('../internals/array-slice');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\nvar max = Math.max;\n\n// `Array.prototype.slice` method\n// https://tc39.es/ecma262/#sec-array.prototype.slice\n// fallback for not array-like ES3 strings and DOM objects\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n slice: function slice(start, end) {\n var O = toIndexedObject(this);\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible\n var Constructor, result, n;\n if (isArray(O)) {\n Constructor = O.constructor;\n // cross-realm fallback\n if (isConstructor(Constructor) && (Constructor === $Array || isArray(Constructor.prototype))) {\n Constructor = undefined;\n } else if (isObject(Constructor)) {\n Constructor = Constructor[SPECIES];\n if (Constructor === null) Constructor = undefined;\n }\n if (Constructor === $Array || Constructor === undefined) {\n return nativeSlice(O, k, fin);\n }\n }\n result = new (Constructor === undefined ? $Array : Constructor)(max(fin - k, 0));\n for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = function (METHOD_NAME, argument) {\n var method = [][METHOD_NAME];\n return !!method && fails(function () {\n // eslint-disable-next-line no-useless-call -- required for testing\n method.call(null, argument || function () { return 1; }, 1);\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar nativeJoin = uncurryThis([].join);\n\nvar ES3_STRINGS = IndexedObject !== Object;\nvar FORCED = ES3_STRINGS || !arrayMethodIsStrict('join', ',');\n\n// `Array.prototype.join` method\n// https://tc39.es/ecma262/#sec-array.prototype.join\n$({ target: 'Array', proto: true, forced: FORCED }, {\n join: function join(separator) {\n return nativeJoin(toIndexedObject(this), separator === undefined ? ',' : separator);\n }\n});\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n var _, done = false;\r\n for (var i = decorators.length - 1; i >= 0; i--) {\r\n var context = {};\r\n for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n if (kind === \"accessor\") {\r\n if (result === void 0) continue;\r\n if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n if (_ = accept(result.get)) descriptor.get = _;\r\n if (_ = accept(result.set)) descriptor.set = _;\r\n if (_ = accept(result.init)) initializers.unshift(_);\r\n }\r\n else if (_ = accept(result)) {\r\n if (kind === \"field\") initializers.unshift(_);\r\n else descriptor[key] = _;\r\n }\r\n }\r\n if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n var useValue = arguments.length > 2;\r\n for (var i = 0; i < initializers.length; i++) {\r\n value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n }\r\n return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n 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;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n var desc = Object.getOwnPropertyDescriptor(m, k);\r\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n desc = { enumerable: true, get: function() { return m[k]; } };\r\n }\r\n Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport default {\r\n __extends,\r\n __assign,\r\n __rest,\r\n __decorate,\r\n __param,\r\n __metadata,\r\n __awaiter,\r\n __generator,\r\n __createBinding,\r\n __exportStar,\r\n __values,\r\n __read,\r\n __spread,\r\n __spreadArrays,\r\n __spreadArray,\r\n __await,\r\n __asyncGenerator,\r\n __asyncDelegator,\r\n __asyncValues,\r\n __makeTemplateObject,\r\n __importStar,\r\n __importDefault,\r\n __classPrivateFieldGet,\r\n __classPrivateFieldSet,\r\n __classPrivateFieldIn,\r\n};\r\n","'use strict';\nvar $ = require('../internals/export');\nvar toObject = require('../internals/to-object');\nvar nativeKeys = require('../internals/object-keys');\nvar fails = require('../internals/fails');\n\nvar FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {\n keys: function keys(it) {\n return nativeKeys(toObject(it));\n }\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\n// `IsRegExp` abstract operation\n// https://tc39.es/ecma262/#sec-isregexp\nmodule.exports = function (it) {\n var isRegExp;\n return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) === 'RegExp');\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar toLength = require('../internals/to-length');\nvar toString = require('../internals/to-string');\nvar notARegExp = require('../internals/not-a-regexp');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');\nvar IS_PURE = require('../internals/is-pure');\n\n// eslint-disable-next-line es/no-string-prototype-startswith -- safe\nvar nativeStartsWith = uncurryThis(''.startsWith);\nvar stringSlice = uncurryThis(''.slice);\nvar min = Math.min;\n\nvar CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');\n// https://github.com/zloirock/core-js/pull/702\nvar MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {\n var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith');\n return descriptor && !descriptor.writable;\n}();\n\n// `String.prototype.startsWith` method\n// https://tc39.es/ecma262/#sec-string.prototype.startswith\n$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {\n startsWith: function startsWith(searchString /* , position = 0 */) {\n var that = toString(requireObjectCoercible(this));\n notARegExp(searchString);\n var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));\n var search = toString(searchString);\n return nativeStartsWith\n ? nativeStartsWith(that, search, index)\n : stringSlice(that, index, index + search.length) === search;\n }\n});\n","'use strict';\nvar isRegExp = require('../internals/is-regexp');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it) {\n if (isRegExp(it)) {\n throw new $TypeError(\"The method doesn't accept regular expressions\");\n } return it;\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\nmodule.exports = function (METHOD_NAME) {\n var regexp = /./;\n try {\n '/./'[METHOD_NAME](regexp);\n } catch (error1) {\n try {\n regexp[MATCH] = false;\n return '/./'[METHOD_NAME](regexp);\n } catch (error2) { /* empty */ }\n } return false;\n};\n","'use strict';\nvar $forEach = require('../internals/array-iteration').forEach;\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar STRICT_METHOD = arrayMethodIsStrict('forEach');\n\n// `Array.prototype.forEach` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.foreach\nmodule.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {\n return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n// eslint-disable-next-line es/no-array-prototype-foreach -- safe\n} : [].forEach;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar forEach = require('../internals/array-for-each');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar handlePrototype = function (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {\n createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);\n } catch (error) {\n CollectionPrototype.forEach = forEach;\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n if (DOMIterables[COLLECTION_NAME]) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype);\n }\n}\n\nhandlePrototype(DOMTokenListPrototype);\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar objectGetPrototypeOf = require('../internals/object-get-prototype-of');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\nvar propertyIsEnumerable = uncurryThis($propertyIsEnumerable);\nvar push = uncurryThis([].push);\n\n// in some IE versions, `propertyIsEnumerable` returns incorrect result on integer keys\n// of `null` prototype objects\nvar IE_BUG = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-create -- safe\n var O = Object.create(null);\n O[2] = 2;\n return !propertyIsEnumerable(O, 2);\n});\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n return function (it) {\n var O = toIndexedObject(it);\n var keys = objectKeys(O);\n var IE_WORKAROUND = IE_BUG && objectGetPrototypeOf(O) === null;\n var length = keys.length;\n var i = 0;\n var result = [];\n var key;\n while (length > i) {\n key = keys[i++];\n if (!DESCRIPTORS || (IE_WORKAROUND ? key in O : propertyIsEnumerable(O, key))) {\n push(result, TO_ENTRIES ? [key, O[key]] : O[key]);\n }\n }\n return result;\n };\n};\n\nmodule.exports = {\n // `Object.entries` method\n // https://tc39.es/ecma262/#sec-object.entries\n entries: createMethod(true),\n // `Object.values` method\n // https://tc39.es/ecma262/#sec-object.values\n values: createMethod(false)\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $entries = require('../internals/object-to-array').entries;\n\n// `Object.entries` method\n// https://tc39.es/ecma262/#sec-object.entries\n$({ target: 'Object', stat: true }, {\n entries: function entries(O) {\n return $entries(O);\n }\n});\n","import {ascending, descending} from \"d3\";\n\nexport function defined(x) {\n return x != null && !Number.isNaN(x);\n}\n\nexport function ascendingDefined(a, b) {\n return +defined(b) - +defined(a) || ascending(a, b);\n}\n\nexport function descendingDefined(a, b) {\n return +defined(b) - +defined(a) || descending(a, b);\n}\n\nexport function nonempty(x) {\n return x != null && `${x}` !== \"\";\n}\n\nexport function finite(x) {\n return isFinite(x) ? x : NaN;\n}\n\nexport function positive(x) {\n return x > 0 && isFinite(x) ? x : NaN;\n}\n\nexport function negative(x) {\n return x < 0 && isFinite(x) ? x : NaN;\n}\n","const re = /^(?:[-+]\\d{2})?\\d{4}(?:-\\d{2}(?:-\\d{2})?)?(?:T\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{3})?)?(?:Z|[-+]\\d{2}:?\\d{2})?)?$/;\n\nexport default function parse(string, fallback) {\n if (!re.test(string += \"\")) return typeof fallback === \"function\" ? fallback(string) : fallback;\n return new Date(string);\n}\n","import {utcSecond, utcMinute, utcHour, utcDay, utcWeek, utcMonth, utcYear} from \"d3\";\nimport {utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSunday} from \"d3\";\nimport {timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear} from \"d3\";\nimport {timeMonday, timeTuesday, timeWednesday, timeThursday, timeFriday, timeSaturday, timeSunday} from \"d3\";\n\nconst timeIntervals = new Map([\n [\"second\", timeSecond],\n [\"minute\", timeMinute],\n [\"hour\", timeHour],\n [\"day\", timeDay],\n [\"week\", timeWeek],\n [\"month\", timeMonth],\n [\"quarter\", timeMonth.every(3)],\n [\"half\", timeMonth.every(6)],\n [\"year\", timeYear],\n [\"monday\", timeMonday],\n [\"tuesday\", timeTuesday],\n [\"wednesday\", timeWednesday],\n [\"thursday\", timeThursday],\n [\"friday\", timeFriday],\n [\"saturday\", timeSaturday],\n [\"sunday\", timeSunday]\n]);\n\nconst utcIntervals = new Map([\n [\"second\", utcSecond],\n [\"minute\", utcMinute],\n [\"hour\", utcHour],\n [\"day\", utcDay],\n [\"week\", utcWeek],\n [\"month\", utcMonth],\n [\"quarter\", utcMonth.every(3)],\n [\"half\", utcMonth.every(6)],\n [\"year\", utcYear],\n [\"monday\", utcMonday],\n [\"tuesday\", utcTuesday],\n [\"wednesday\", utcWednesday],\n [\"thursday\", utcThursday],\n [\"friday\", utcFriday],\n [\"saturday\", utcSaturday],\n [\"sunday\", utcSunday]\n]);\n\nexport function maybeTimeInterval(interval) {\n const i = timeIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n\nexport function maybeUtcInterval(interval) {\n const i = utcIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n","import {parse as isoParse} from \"isoformat\";\nimport {color, descending, range as rangei, quantile} from \"d3\";\nimport {maybeTimeInterval, maybeUtcInterval} from \"./time.js\";\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\nexport const TypedArray = Object.getPrototypeOf(Uint8Array);\nconst objectToString = Object.prototype.toString;\n\nexport function valueof(data, value, type) {\n const valueType = typeof value;\n return valueType === \"string\"\n ? maybeTypedMap(data, field(value), type)\n : valueType === \"function\"\n ? maybeTypedMap(data, value, type)\n : valueType === \"number\" || value instanceof Date || valueType === \"boolean\"\n ? map(data, constant(value), type)\n : typeof value?.transform === \"function\"\n ? maybeTypedArrayify(value.transform(data), type)\n : maybeTypedArrayify(value, type);\n}\n\nfunction maybeTypedMap(data, f, type) {\n return map(data, type?.prototype instanceof TypedArray ? floater(f) : f, type);\n}\n\nfunction maybeTypedArrayify(data, type) {\n return type === undefined\n ? arrayify(data) // preserve undefined type\n : data instanceof type\n ? data\n : type.prototype instanceof TypedArray && !(data instanceof TypedArray)\n ? type.from(data, coerceNumber)\n : type.from(data);\n}\n\nfunction floater(f) {\n return (d, i) => coerceNumber(f(d, i));\n}\n\nexport const field = (name) => (d) => d[name];\nexport const indexOf = {transform: range};\nexport const identity = {transform: (d) => d};\nexport const zero = () => 0;\nexport const one = () => 1;\nexport const yes = () => true;\nexport const string = (x) => (x == null ? x : `${x}`);\nexport const number = (x) => (x == null ? x : +x);\nexport const boolean = (x) => (x == null ? x : !!x);\nexport const first = (x) => (x ? x[0] : undefined);\nexport const second = (x) => (x ? x[1] : undefined);\nexport const third = (x) => (x ? x[2] : undefined);\nexport const constant = (x) => () => x;\n\n// Converts a string like “p25” into a function that takes an index I and an\n// accessor function f, returning the corresponding percentile value.\nexport function percentile(reduce) {\n const p = +`${reduce}`.slice(1) / 100;\n return (I, f) => quantile(I, p, f);\n}\n\n// If the values are specified as a typed array, no coercion is required.\nexport function coerceNumbers(values) {\n return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array);\n}\n\n// Unlike Mark’s number, here we want to convert null and undefined to NaN since\n// the result will be stored in a Float64Array and we don’t want null to be\n// coerced to zero. We use Number instead of unary + to allow BigInt coercion.\nfunction coerceNumber(x) {\n return x == null ? NaN : Number(x);\n}\n\nexport function coerceDates(values) {\n return map(values, coerceDate);\n}\n\n// When coercing strings to dates, we only want to allow the ISO 8601 format\n// since the built-in string parsing of the Date constructor varies across\n// browsers. (In the future, this could be made more liberal if desired, though\n// it is still generally preferable to do date parsing yourself explicitly,\n// rather than rely on Plot.) Any non-string values are coerced to number first\n// and treated as milliseconds since UNIX epoch.\nexport function coerceDate(x) {\n return x instanceof Date && !isNaN(x)\n ? x\n : typeof x === \"string\"\n ? isoParse(x)\n : x == null || isNaN((x = +x))\n ? undefined\n : new Date(x);\n}\n\n// Some channels may allow a string constant to be specified; to differentiate\n// string constants (e.g., \"red\") from named fields (e.g., \"date\"), this\n// function tests whether the given value is a CSS color string and returns a\n// tuple [channel, constant] where one of the two is undefined, and the other is\n// the given value. If you wish to reference a named field that is also a valid\n// CSS color, use an accessor (d => d.red) instead.\nexport function maybeColorChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null ? [undefined, \"none\"] : isColor(value) ? [undefined, value] : [value, undefined];\n}\n\n// Similar to maybeColorChannel, this tests whether the given value is a number\n// indicating a constant, and otherwise assumes that it’s a channel value.\nexport function maybeNumberChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null || typeof value === \"number\" ? [undefined, value] : [value, undefined];\n}\n\n// Validates the specified optional string against the allowed list of keywords.\nexport function maybeKeyword(input, name, allowed) {\n if (input != null) return keyword(input, name, allowed);\n}\n\n// Validates the specified required string against the allowed list of keywords.\nexport function keyword(input, name, allowed) {\n const i = `${input}`.toLowerCase();\n if (!allowed.includes(i)) throw new Error(`invalid ${name}: ${input}`);\n return i;\n}\n\n// Promotes the specified data to an array as needed.\nexport function arrayify(data) {\n return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data);\n}\n\n// An optimization of type.from(values, f): if the given values are already an\n// instanceof the desired array type, the faster values.map method is used.\nexport function map(values, f, type = Array) {\n return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f);\n}\n\n// An optimization of type.from(values): if the given values are already an\n// instanceof the desired array type, the faster values.slice method is used.\nexport function slice(values, type = Array) {\n return values instanceof type ? values.slice() : type.from(values);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a primitive value.\nexport function isObject(option) {\n return option?.toString === objectToString;\n}\n\n// Disambiguates a scale options object (e.g., {color: {type: \"linear\"}}) from\n// some other option (e.g., {color: \"red\"}). When creating standalone legends,\n// this is used to test whether a scale is defined; this should be consistent\n// with inferScaleType when there are no channels associated with the scale, and\n// if this returns true, then normalizeScale must return non-null.\nexport function isScaleOptions(option) {\n return isObject(option) && (option.type !== undefined || option.domain !== undefined);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a channel value\n// definition expressed as a channel transform (e.g., {transform: …}).\nexport function isOptions(option) {\n return isObject(option) && typeof option.transform !== \"function\";\n}\n\n// Disambiguates a sort transform (e.g., {sort: \"date\"}) from a channel domain\n// sort definition (e.g., {sort: {y: \"x\"}}).\nexport function isDomainSort(sort) {\n return isOptions(sort) && sort.value === undefined && sort.channel === undefined;\n}\n\n// For marks specified either as [0, x] or [x1, x2], such as areas and bars.\nexport function maybeZero(x, x1, x2, x3 = identity) {\n if (x1 === undefined && x2 === undefined) {\n // {x} or {}\n (x1 = 0), (x2 = x === undefined ? x3 : x);\n } else if (x1 === undefined) {\n // {x, x2} or {x2}\n x1 = x === undefined ? 0 : x;\n } else if (x2 === undefined) {\n // {x, x1} or {x1}\n x2 = x === undefined ? 0 : x;\n }\n return [x1, x2];\n}\n\n// For marks that have x and y channels (e.g., cell, dot, line, text).\nexport function maybeTuple(x, y) {\n return x === undefined && y === undefined ? [first, second] : [x, y];\n}\n\n// A helper for extracting the z channel, if it is variable. Used by transforms\n// that require series, such as moving average and normalize.\nexport function maybeZ({z, fill, stroke} = {}) {\n if (z === undefined) [z] = maybeColorChannel(fill);\n if (z === undefined) [z] = maybeColorChannel(stroke);\n return z;\n}\n\n// Returns a Uint32Array with elements [0, 1, 2, … data.length - 1].\nexport function range(data) {\n const n = data.length;\n const r = new Uint32Array(n);\n for (let i = 0; i < n; ++i) r[i] = i;\n return r;\n}\n\n// Returns a filtered range of data given the test function.\nexport function where(data, test) {\n return range(data).filter((i) => test(data[i], i, data));\n}\n\n// Returns an array [values[index[0]], values[index[1]], …].\nexport function take(values, index) {\n return map(index, (i) => values[i]);\n}\n\n// Based on InternMap (d3.group).\nexport function keyof(value) {\n return value !== null && typeof value === \"object\" ? value.valueOf() : value;\n}\n\nexport function maybeInput(key, options) {\n if (options[key] !== undefined) return options[key];\n switch (key) {\n case \"x1\":\n case \"x2\":\n key = \"x\";\n break;\n case \"y1\":\n case \"y2\":\n key = \"y\";\n break;\n }\n return options[key];\n}\n\nexport function column(source) {\n // Defines a column whose values are lazily populated by calling the returned\n // setter. If the given source is labeled, the label is propagated to the\n // returned column definition.\n let value;\n return [\n {\n transform: () => value,\n label: labelof(source)\n },\n (v) => (value = v)\n ];\n}\n\n// Like column, but allows the source to be null.\nexport function maybeColumn(source) {\n return source == null ? [source] : column(source);\n}\n\nexport function labelof(value, defaultValue) {\n return typeof value === \"string\" ? value : value && value.label !== undefined ? value.label : defaultValue;\n}\n\n// Assuming that both x1 and x2 and lazy columns (per above), this derives a new\n// a column that’s the average of the two, and which inherits the column label\n// (if any). Both input columns are assumed to be quantitative. If either column\n// is temporal, the returned column is also temporal.\nexport function mid(x1, x2) {\n return {\n transform(data) {\n const X1 = x1.transform(data);\n const X2 = x2.transform(data);\n return isTemporal(X1) || isTemporal(X2)\n ? map(X1, (_, i) => new Date((+X1[i] + +X2[i]) / 2))\n : map(X1, (_, i) => (+X1[i] + +X2[i]) / 2, Float64Array);\n },\n label: x1.label\n };\n}\n\n// If interval is not nullish, converts interval shorthand such as a number (for\n// multiples) or a time interval name (such as “day”) to a {floor, offset,\n// range} object similar to a D3 time interval.\nexport function maybeInterval(interval, type) {\n if (interval == null) return;\n if (typeof interval === \"number\") {\n if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval;\n const n = Math.abs(interval);\n return interval < 0\n ? {\n floor: (d) => Math.floor(d * n) / n,\n offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo * n), hi * n).map((x) => x / n)\n }\n : {\n floor: (d) => Math.floor(d / n) * n,\n offset: (d) => d + n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo / n), hi / n).map((x) => x * n)\n };\n }\n if (typeof interval === \"string\") return (type === \"time\" ? maybeTimeInterval : maybeUtcInterval)(interval);\n if (typeof interval.floor !== \"function\") throw new Error(\"invalid interval; missing floor method\");\n if (typeof interval.offset !== \"function\") throw new Error(\"invalid interval; missing offset method\");\n return interval;\n}\n\n// Like maybeInterval, but requires a range method too.\nexport function maybeRangeInterval(interval, type) {\n interval = maybeInterval(interval, type);\n if (interval && typeof interval.range !== \"function\") throw new Error(\"invalid interval: missing range method\");\n return interval;\n}\n\n// Like maybeRangeInterval, but requires a ceil method too.\nexport function maybeNiceInterval(interval, type) {\n interval = maybeRangeInterval(interval, type);\n if (interval && typeof interval.ceil !== \"function\") throw new Error(\"invalid interval: missing ceil method\");\n return interval;\n}\n\n// This distinguishes between per-dimension options and a standalone value.\nexport function maybeValue(value) {\n return value === undefined || isOptions(value) ? value : {value};\n}\n\n// Coerces the given channel values (if any) to numbers. This is useful when\n// values will be interpolated into other code, such as an SVG transform, and\n// where we don’t wish to allow unexpected behavior for weird input.\nexport function numberChannel(source) {\n return source == null\n ? null\n : {\n transform: (data) => valueof(data, source, Float64Array),\n label: labelof(source)\n };\n}\n\nexport function isTuples(data) {\n if (!isIterable(data)) return false;\n for (const d of data) {\n if (d == null) continue;\n return typeof d === \"object\" && \"0\" in d && \"1\" in d;\n }\n}\n\nexport function isIterable(value) {\n return value && typeof value[Symbol.iterator] === \"function\";\n}\n\nexport function isTextual(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value !== \"object\" || value instanceof Date;\n }\n}\n\nexport function isOrdinal(values) {\n for (const value of values) {\n if (value == null) continue;\n const type = typeof value;\n return type === \"string\" || type === \"boolean\";\n }\n}\n\nexport function isTemporal(values) {\n for (const value of values) {\n if (value == null) continue;\n return value instanceof Date;\n }\n}\n\n// Are these strings that might represent dates? This is stricter than ISO 8601\n// because we want to ignore false positives on numbers; for example, the string\n// \"1192\" is more likely to represent a number than a date even though it is\n// valid ISO 8601 representing 1192-01-01.\nexport function isTemporalString(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"string\" && isNaN(value) && isoParse(value);\n }\n}\n\n// Are these strings that might represent numbers? This is stricter than\n// coercion because we want to ignore false positives on e.g. empty strings.\nexport function isNumericString(values) {\n for (const value of values) {\n if (value == null) continue;\n if (typeof value !== \"string\") return false;\n if (!value.trim()) continue;\n return !isNaN(value);\n }\n}\n\nexport function isNumeric(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"number\";\n }\n}\n\n// Returns true if every non-null value in the specified iterable of values\n// passes the specified predicate, and there is at least one non-null value;\n// returns false if at least one non-null value does not pass the specified\n// predicate; otherwise returns undefined (as if all values are null).\nexport function isEvery(values, is) {\n let every;\n for (const value of values) {\n if (value == null) continue;\n if (!is(value)) return false;\n every = true;\n }\n return every;\n}\n\n// Mostly relies on d3-color, with a few extra color keywords. Currently this\n// strictly requires that the value be a string; we might want to apply string\n// coercion here, though note that d3-color instances would need to support\n// valueOf to work correctly with InternMap.\n// https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint\nexport function isColor(value) {\n if (typeof value !== \"string\") return false;\n value = value.toLowerCase().trim();\n return (\n value === \"none\" ||\n value === \"currentcolor\" ||\n (value.startsWith(\"url(\") && value.endsWith(\")\")) || // , e.g. pattern or gradient\n (value.startsWith(\"var(\") && value.endsWith(\")\")) || // CSS variable\n color(value) !== null\n );\n}\n\nexport function isOpacity(value) {\n return typeof value === \"number\" && ((0 <= value && value <= 1) || isNaN(value));\n}\n\nexport function isNoneish(value) {\n return value == null || isNone(value);\n}\n\nexport function isNone(value) {\n return /^\\s*none\\s*$/i.test(value);\n}\n\nexport function isRound(value) {\n return /^\\s*round\\s*$/i.test(value);\n}\n\nexport function maybeFrameAnchor(value = \"middle\") {\n return keyword(value, \"frameAnchor\", [\n \"middle\",\n \"top-left\",\n \"top\",\n \"top-right\",\n \"right\",\n \"bottom-right\",\n \"bottom\",\n \"bottom-left\",\n \"left\"\n ]);\n}\n\n// Like a sort comparator, returns a positive value if the given array of values\n// is in ascending order, a negative value if the values are in descending\n// order. Assumes monotonicity; only tests the first and last values.\nexport function orderof(values) {\n if (values == null) return;\n const first = values[0];\n const last = values[values.length - 1];\n return descending(first, last);\n}\n\n// Unlike {...defaults, ...options}, this ensures that any undefined (but\n// present) properties in options inherit the given default value.\nexport function inherit(options = {}, ...rest) {\n let o = options;\n for (const defaults of rest) {\n for (const key in defaults) {\n if (o[key] === undefined) {\n const value = defaults[key];\n if (o === options) o = {...o, [key]: value};\n else o[key] = value;\n }\n }\n }\n return o;\n}\n\n// Given an iterable of named things (objects with a name property), returns a\n// corresponding object with properties associated with the given name.\nexport function named(things) {\n console.warn(\"named iterables are deprecated; please use an object instead\");\n const names = new Set();\n return Object.fromEntries(\n Array.from(things, (thing) => {\n const {name} = thing;\n if (name == null) throw new Error(\"missing name\");\n const key = `${name}`;\n if (key === \"__proto__\") throw new Error(`illegal name: ${key}`);\n if (names.has(key)) throw new Error(`duplicate name: ${key}`);\n names.add(key);\n return [name, thing];\n })\n );\n}\n\nexport function maybeNamed(things) {\n return isIterable(things) ? named(things) : things;\n}\n","// Positional scales have associated axes, and for ordinal data, a point or band\n// scale is used instead of an ordinal scale.\nexport const position = Symbol(\"position\");\n\n// Color scales default to the turbo interpolator for quantitative data, and to\n// the Tableau10 scheme for ordinal data. Color scales may also have an\n// associated legend.\nexport const color = Symbol(\"color\");\n\n// Radius scales default to the sqrt type, have a default range of [0, 3], and a\n// default domain from 0 to the median first quartile of associated channels.\nexport const radius = Symbol(\"radius\");\n\n// Length scales default to the linear type, have a default range of [0, 12],\n// and a default domain from 0 to the median median of associated channels.\nexport const length = Symbol(\"length\");\n\n// Opacity scales have a default range of [0, 1], and a default domain from 0 to\n// the maximum value of associated channels.\nexport const opacity = Symbol(\"opacity\");\n\n// Symbol scales have a default range of categorical symbols.\nexport const symbol = Symbol(\"symbol\");\n\n// TODO Rather than hard-coding the list of known scale names, collect the names\n// and categories for each plot specification, so that custom marks can register\n// custom scales.\nexport const registry = new Map([\n [\"x\", position],\n [\"y\", position],\n [\"fx\", position],\n [\"fy\", position],\n [\"r\", radius],\n [\"color\", color],\n [\"opacity\", opacity],\n [\"symbol\", symbol],\n [\"length\", length]\n]);\n","import {symbolAsterisk, symbolDiamond2, symbolPlus, symbolSquare2, symbolTriangle2, symbolTimes} from \"d3\";\nimport {symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye} from \"d3\";\n\nexport const sqrt3 = Math.sqrt(3);\nexport const sqrt4_3 = 2 / sqrt3;\n\nconst symbolHexagon = {\n draw(context, size) {\n const rx = Math.sqrt(size / Math.PI),\n ry = rx * sqrt4_3,\n hy = ry / 2;\n context.moveTo(0, ry);\n context.lineTo(rx, hy);\n context.lineTo(rx, -hy);\n context.lineTo(0, -ry);\n context.lineTo(-rx, -hy);\n context.lineTo(-rx, hy);\n context.closePath();\n }\n};\n\nconst symbols = new Map([\n [\"asterisk\", symbolAsterisk],\n [\"circle\", symbolCircle],\n [\"cross\", symbolCross],\n [\"diamond\", symbolDiamond],\n [\"diamond2\", symbolDiamond2],\n [\"hexagon\", symbolHexagon],\n [\"plus\", symbolPlus],\n [\"square\", symbolSquare],\n [\"square2\", symbolSquare2],\n [\"star\", symbolStar],\n [\"times\", symbolTimes],\n [\"triangle\", symbolTriangle],\n [\"triangle2\", symbolTriangle2],\n [\"wye\", symbolWye]\n]);\n\nfunction isSymbolObject(value) {\n return value && typeof value.draw === \"function\";\n}\n\nexport function isSymbol(value) {\n if (isSymbolObject(value)) return true;\n if (typeof value !== \"string\") return false;\n return symbols.has(value.toLowerCase());\n}\n\nexport function maybeSymbol(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return symbol;\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return value;\n throw new Error(`invalid symbol: ${symbol}`);\n}\n\nexport function maybeSymbolChannel(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return [undefined, symbol];\n if (typeof symbol === \"string\") {\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return [undefined, value];\n }\n return [symbol, undefined];\n}\n","let warnings = 0;\n\nexport function consumeWarnings() {\n const w = warnings;\n warnings = 0;\n return w;\n}\n\nexport function warn(message) {\n console.warn(message);\n ++warnings;\n}\n","import {\n interpolateBlues,\n interpolateBrBG,\n interpolateBuGn,\n interpolateBuPu,\n interpolateGnBu,\n interpolateGreens,\n interpolateGreys,\n interpolateOranges,\n interpolateOrRd,\n interpolatePiYG,\n interpolatePRGn,\n interpolatePuBu,\n interpolatePuBuGn,\n interpolatePuOr,\n interpolatePuRd,\n interpolatePurples,\n interpolateRdBu,\n interpolateRdGy,\n interpolateRdPu,\n interpolateRdYlBu,\n interpolateRdYlGn,\n interpolateReds,\n interpolateSpectral,\n interpolateYlGn,\n interpolateYlGnBu,\n interpolateYlOrBr,\n interpolateYlOrRd,\n interpolateTurbo,\n interpolateViridis,\n interpolateMagma,\n interpolateInferno,\n interpolatePlasma,\n interpolateCividis,\n interpolateCubehelixDefault,\n interpolateWarm,\n interpolateCool,\n interpolateRainbow,\n interpolateSinebow,\n quantize,\n schemeAccent,\n schemeBlues,\n schemeBrBG,\n schemeBuGn,\n schemeBuPu,\n schemeCategory10,\n schemeDark2,\n schemeGnBu,\n schemeGreens,\n schemeGreys,\n schemeOranges,\n schemeOrRd,\n schemePaired,\n schemePastel1,\n schemePastel2,\n schemePiYG,\n schemePRGn,\n schemePuBu,\n schemePuBuGn,\n schemePuOr,\n schemePuRd,\n schemePurples,\n schemeRdBu,\n schemeRdGy,\n schemeRdPu,\n schemeRdYlBu,\n schemeRdYlGn,\n schemeReds,\n schemeSet1,\n schemeSet2,\n schemeSet3,\n schemeSpectral,\n schemeTableau10,\n schemeYlGn,\n schemeYlGnBu,\n schemeYlOrBr,\n schemeYlOrRd\n} from \"d3\";\n\nconst ordinalSchemes = new Map([\n // categorical\n [\"accent\", schemeAccent],\n [\"category10\", schemeCategory10],\n [\"dark2\", schemeDark2],\n [\"paired\", schemePaired],\n [\"pastel1\", schemePastel1],\n [\"pastel2\", schemePastel2],\n [\"set1\", schemeSet1],\n [\"set2\", schemeSet2],\n [\"set3\", schemeSet3],\n [\"tableau10\", schemeTableau10],\n\n // diverging\n [\"brbg\", scheme11(schemeBrBG, interpolateBrBG)],\n [\"prgn\", scheme11(schemePRGn, interpolatePRGn)],\n [\"piyg\", scheme11(schemePiYG, interpolatePiYG)],\n [\"puor\", scheme11(schemePuOr, interpolatePuOr)],\n [\"rdbu\", scheme11(schemeRdBu, interpolateRdBu)],\n [\"rdgy\", scheme11(schemeRdGy, interpolateRdGy)],\n [\"rdylbu\", scheme11(schemeRdYlBu, interpolateRdYlBu)],\n [\"rdylgn\", scheme11(schemeRdYlGn, interpolateRdYlGn)],\n [\"spectral\", scheme11(schemeSpectral, interpolateSpectral)],\n\n // reversed diverging (for temperature data)\n [\"burd\", scheme11r(schemeRdBu, interpolateRdBu)],\n [\"buylrd\", scheme11r(schemeRdYlBu, interpolateRdYlBu)],\n\n // sequential (single-hue)\n [\"blues\", scheme9(schemeBlues, interpolateBlues)],\n [\"greens\", scheme9(schemeGreens, interpolateGreens)],\n [\"greys\", scheme9(schemeGreys, interpolateGreys)],\n [\"oranges\", scheme9(schemeOranges, interpolateOranges)],\n [\"purples\", scheme9(schemePurples, interpolatePurples)],\n [\"reds\", scheme9(schemeReds, interpolateReds)],\n\n // sequential (multi-hue)\n [\"turbo\", schemei(interpolateTurbo)],\n [\"viridis\", schemei(interpolateViridis)],\n [\"magma\", schemei(interpolateMagma)],\n [\"inferno\", schemei(interpolateInferno)],\n [\"plasma\", schemei(interpolatePlasma)],\n [\"cividis\", schemei(interpolateCividis)],\n [\"cubehelix\", schemei(interpolateCubehelixDefault)],\n [\"warm\", schemei(interpolateWarm)],\n [\"cool\", schemei(interpolateCool)],\n [\"bugn\", scheme9(schemeBuGn, interpolateBuGn)],\n [\"bupu\", scheme9(schemeBuPu, interpolateBuPu)],\n [\"gnbu\", scheme9(schemeGnBu, interpolateGnBu)],\n [\"orrd\", scheme9(schemeOrRd, interpolateOrRd)],\n [\"pubu\", scheme9(schemePuBu, interpolatePuBu)],\n [\"pubugn\", scheme9(schemePuBuGn, interpolatePuBuGn)],\n [\"purd\", scheme9(schemePuRd, interpolatePuRd)],\n [\"rdpu\", scheme9(schemeRdPu, interpolateRdPu)],\n [\"ylgn\", scheme9(schemeYlGn, interpolateYlGn)],\n [\"ylgnbu\", scheme9(schemeYlGnBu, interpolateYlGnBu)],\n [\"ylorbr\", scheme9(schemeYlOrBr, interpolateYlOrBr)],\n [\"ylorrd\", scheme9(schemeYlOrRd, interpolateYlOrRd)],\n\n // cyclical\n [\"rainbow\", schemeicyclical(interpolateRainbow)],\n [\"sinebow\", schemeicyclical(interpolateSinebow)]\n]);\n\nfunction scheme9(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 1) return [scheme[3][1]]; // favor midpoint\n if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker\n n = Math.max(3, Math.floor(n));\n return n > 9 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11r(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse();\n };\n}\n\nfunction schemei(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.max(2, Math.floor(n)));\n}\n\nfunction schemeicyclical(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.floor(n) + 1).slice(0, -1);\n}\n\nexport function ordinalScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`);\n return ordinalSchemes.get(s);\n}\n\nexport function ordinalRange(scheme, length) {\n const s = ordinalScheme(scheme);\n const r = typeof s === \"function\" ? s({length}) : s;\n return r.length !== length ? r.slice(0, length) : r;\n}\n\n// If the specified domain contains only booleans (ignoring null and undefined),\n// returns a corresponding range where false is mapped to the low color and true\n// is mapped to the high color of the specified scheme.\nexport function maybeBooleanRange(domain, scheme = \"greys\") {\n const range = new Set();\n const [f, t] = ordinalRange(scheme, 2);\n for (const value of domain) {\n if (value == null) continue;\n if (value === true) range.add(t);\n else if (value === false) range.add(f);\n else return;\n }\n return [...range];\n}\n\nconst quantitativeSchemes = new Map([\n // diverging\n [\"brbg\", interpolateBrBG],\n [\"prgn\", interpolatePRGn],\n [\"piyg\", interpolatePiYG],\n [\"puor\", interpolatePuOr],\n [\"rdbu\", interpolateRdBu],\n [\"rdgy\", interpolateRdGy],\n [\"rdylbu\", interpolateRdYlBu],\n [\"rdylgn\", interpolateRdYlGn],\n [\"spectral\", interpolateSpectral],\n\n // reversed diverging (for temperature data)\n [\"burd\", (t) => interpolateRdBu(1 - t)],\n [\"buylrd\", (t) => interpolateRdYlBu(1 - t)],\n\n // sequential (single-hue)\n [\"blues\", interpolateBlues],\n [\"greens\", interpolateGreens],\n [\"greys\", interpolateGreys],\n [\"purples\", interpolatePurples],\n [\"reds\", interpolateReds],\n [\"oranges\", interpolateOranges],\n\n // sequential (multi-hue)\n [\"turbo\", interpolateTurbo],\n [\"viridis\", interpolateViridis],\n [\"magma\", interpolateMagma],\n [\"inferno\", interpolateInferno],\n [\"plasma\", interpolatePlasma],\n [\"cividis\", interpolateCividis],\n [\"cubehelix\", interpolateCubehelixDefault],\n [\"warm\", interpolateWarm],\n [\"cool\", interpolateCool],\n [\"bugn\", interpolateBuGn],\n [\"bupu\", interpolateBuPu],\n [\"gnbu\", interpolateGnBu],\n [\"orrd\", interpolateOrRd],\n [\"pubugn\", interpolatePuBuGn],\n [\"pubu\", interpolatePuBu],\n [\"purd\", interpolatePuRd],\n [\"rdpu\", interpolateRdPu],\n [\"ylgnbu\", interpolateYlGnBu],\n [\"ylgn\", interpolateYlGn],\n [\"ylorbr\", interpolateYlOrBr],\n [\"ylorrd\", interpolateYlOrRd],\n\n // cyclical\n [\"rainbow\", interpolateRainbow],\n [\"sinebow\", interpolateSinebow]\n]);\n\nexport function quantitativeScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`);\n return quantitativeSchemes.get(s);\n}\n\nconst divergingSchemes = new Set([\n \"brbg\",\n \"prgn\",\n \"piyg\",\n \"puor\",\n \"rdbu\",\n \"rdgy\",\n \"rdylbu\",\n \"rdylgn\",\n \"spectral\",\n \"burd\",\n \"buylrd\"\n]);\n\nexport function isDivergingScheme(scheme) {\n return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase());\n}\n","import {\n descending,\n extent,\n interpolateHcl,\n interpolateHsl,\n interpolateLab,\n interpolateNumber,\n interpolateRgb,\n interpolateRound,\n min,\n max,\n median,\n quantile,\n quantize,\n reverse as reverseof,\n scaleLinear,\n scaleLog,\n scalePow,\n scaleQuantile,\n scaleSymlog,\n scaleThreshold,\n scaleIdentity,\n ticks\n} from \"d3\";\nimport {positive, negative, finite} from \"../defined.js\";\nimport {arrayify, constant, orderof, slice, maybeNiceInterval, maybeRangeInterval} from \"../options.js\";\nimport {ordinalRange, quantitativeScheme} from \"./schemes.js\";\nimport {registry, radius, opacity, color, length} from \"./index.js\";\n\nexport const flip = (i) => (t) => i(1 - t);\nconst unit = [0, 1];\n\nconst interpolators = new Map([\n // numbers\n [\"number\", interpolateNumber],\n\n // color spaces\n [\"rgb\", interpolateRgb],\n [\"hsl\", interpolateHsl],\n [\"hcl\", interpolateHcl],\n [\"lab\", interpolateLab]\n]);\n\nexport function maybeInterpolator(interpolate) {\n const i = `${interpolate}`.toLowerCase();\n if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`);\n return interpolators.get(i);\n}\n\nexport function createScaleQ(\n key,\n scale,\n channels,\n {\n type,\n nice,\n clamp,\n zero,\n domain = inferAutoDomain(key, channels),\n unknown,\n round,\n scheme,\n interval,\n range = registry.get(key) === radius\n ? inferRadialRange(channels, domain)\n : registry.get(key) === length\n ? inferLengthRange(channels, domain)\n : registry.get(key) === opacity\n ? unit\n : undefined,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : type === \"cyclical\" ? \"rainbow\" : \"turbo\")\n : round\n ? interpolateRound\n : interpolateNumber,\n reverse\n }\n) {\n interval = maybeRangeInterval(interval, type);\n if (type === \"cyclical\" || type === \"sequential\") type = \"linear\"; // shorthand for color schemes\n reverse = !!reverse;\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n if (interpolate.length === 1) {\n if (reverse) {\n interpolate = flip(interpolate);\n reverse = false;\n }\n if (range === undefined) {\n range = Float64Array.from(domain, (_, i) => i / (domain.length - 1));\n if (range.length === 2) range = unit; // optimize common case of [0, 1]\n }\n scale.interpolate((range === unit ? constant : interpolatePiecewise)(interpolate));\n } else {\n scale.interpolate(interpolate);\n }\n\n // If a zero option is specified, we assume that the domain is numeric, and we\n // want to ensure that the domain crosses zero. However, note that the domain\n // may be reversed (descending) so we shouldn’t assume that the first value is\n // smaller than the last; and also it’s possible that the domain has more than\n // two values for a “poly” scale. And lastly be careful not to mutate input!\n if (zero) {\n const [min, max] = extent(domain);\n if (min > 0 || max < 0) {\n domain = slice(domain);\n if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0;\n // [2, 1] or [-2, -1]\n else domain[0] = 0; // [1, 2] or [-1, -2]\n }\n }\n\n if (reverse) domain = reverseof(domain);\n scale.domain(domain).unknown(unknown);\n if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain());\n if (range !== undefined) scale.range(range);\n if (clamp) scale.clamp(clamp);\n return {type, domain, range, scale, interpolate, interval};\n}\n\nfunction maybeNice(nice, type) {\n return nice === true ? undefined : typeof nice === \"number\" ? nice : maybeNiceInterval(nice, type);\n}\n\nexport function createScaleLinear(key, channels, options) {\n return createScaleQ(key, scaleLinear(), channels, options);\n}\n\nexport function createScaleSqrt(key, channels, options) {\n return createScalePow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScalePow(key, channels, {exponent = 1, ...options}) {\n return createScaleQ(key, scalePow().exponent(exponent), channels, {...options, type: \"pow\"});\n}\n\nexport function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) {\n return createScaleQ(key, scaleLog().base(base), channels, {...options, domain});\n}\n\nexport function createScaleSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleQ(key, scaleSymlog().constant(constant), channels, options);\n}\n\nexport function createScaleQuantile(\n key,\n channels,\n {\n range,\n quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead\n n = quantiles,\n scheme = \"rdylbu\",\n domain = inferQuantileDomain(channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n if (range === undefined) {\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n }\n if (domain.length > 0) {\n domain = scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles();\n }\n return createScaleThreshold(key, channels, {domain, range, reverse, unknown});\n}\n\nexport function createScaleQuantize(\n key,\n channels,\n {\n range,\n n = range === undefined ? 5 : (range = [...range]).length,\n scheme = \"rdylbu\",\n domain = inferAutoDomain(key, channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n const [min, max] = extent(domain);\n let thresholds;\n if (range === undefined) {\n thresholds = ticks(min, max, n); // approximate number of nice, round thresholds\n if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound\n if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound\n n = thresholds.length + 1;\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n } else {\n thresholds = quantize(interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range\n if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types\n }\n if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain\n return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown});\n}\n\nexport function createScaleThreshold(\n key,\n channels,\n {\n domain = [0], // explicit thresholds in ascending order\n unknown,\n scheme = \"rdylbu\",\n interpolate,\n range = interpolate !== undefined\n ? quantize(interpolate, domain.length + 1)\n : registry.get(key) === color\n ? ordinalRange(scheme, domain.length + 1)\n : undefined,\n reverse\n }\n) {\n domain = arrayify(domain);\n const sign = orderof(domain); // preserve descending domain\n if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`);\n if (reverse) range = reverseof(range); // domain ascending, so reverse range\n return {\n type: \"threshold\",\n scale: scaleThreshold(sign < 0 ? reverseof(domain) : domain, range === undefined ? [] : range).unknown(unknown),\n domain,\n range\n };\n}\n\nfunction isOrdered(domain, sign) {\n for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) {\n const s = descending(d, (d = domain[i]));\n if (s !== 0 && s !== sign) return false;\n }\n return true;\n}\n\nexport function createScaleIdentity() {\n return {type: \"identity\", scale: scaleIdentity()};\n}\n\nexport function inferDomain(channels, f = finite) {\n return channels.length\n ? [\n min(channels, ({value}) => (value === undefined ? value : min(value, f))),\n max(channels, ({value}) => (value === undefined ? value : max(value, f)))\n ]\n : [0, 1];\n}\n\nfunction inferAutoDomain(key, channels) {\n const type = registry.get(key);\n return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain)(channels);\n}\n\nfunction inferZeroDomain(channels) {\n return [0, channels.length ? max(channels, ({value}) => (value === undefined ? value : max(value, finite))) : 1];\n}\n\n// We don’t want the upper bound of the radial domain to be zero, as this would\n// be degenerate, so we ignore nonpositive values. We also don’t want the\n// maximum default radius to exceed 30px.\nfunction inferRadialRange(channels, domain) {\n const hint = channels.find(({radius}) => radius !== undefined);\n if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins\n const h25 = quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : quantile(value, 0.25, positive)));\n const range = domain.map((d) => 3 * Math.sqrt(d / h25));\n const k = 30 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\n// We want a length scale’s domain to go from zero to a positive value, and to\n// treat negative lengths if any as inverted vectors of equivalent magnitude. We\n// also don’t want the maximum default length to exceed 60px.\nfunction inferLengthRange(channels, domain) {\n const h50 = median(channels, ({value}) => (value === undefined ? NaN : median(value, Math.abs)));\n const range = domain.map((d) => (12 * d) / h50);\n const k = 60 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\nfunction inferLogDomain(channels) {\n for (const {value} of channels) {\n if (value !== undefined) {\n for (let v of value) {\n if (v > 0) return inferDomain(channels, positive);\n if (v < 0) return inferDomain(channels, negative);\n }\n }\n }\n return [1, 10];\n}\n\nfunction inferQuantileDomain(channels) {\n const domain = [];\n for (const {value} of channels) {\n if (value === undefined) continue;\n for (const v of value) domain.push(v);\n }\n return domain;\n}\n\nexport function interpolatePiecewise(interpolate) {\n return (i, j) => (t) => interpolate(i + t * (j - i));\n}\n","import {\n descending,\n interpolateNumber,\n interpolateRgb,\n piecewise,\n scaleDiverging,\n scaleDivergingLog,\n scaleDivergingPow,\n scaleDivergingSymlog\n} from \"d3\";\nimport {positive, negative} from \"../defined.js\";\nimport {quantitativeScheme} from \"./schemes.js\";\nimport {registry, color} from \"./index.js\";\nimport {inferDomain, maybeInterpolator, flip, interpolatePiecewise} from \"./quantitative.js\";\n\nfunction createScaleD(\n key,\n scale,\n transform,\n channels,\n {\n type,\n nice,\n clamp,\n domain = inferDomain(channels),\n unknown,\n pivot = 0,\n scheme,\n range,\n symmetric = true,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : \"rdbu\")\n : interpolateNumber,\n reverse\n }\n) {\n pivot = +pivot;\n let [min, max] = domain;\n if (descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse);\n min = Math.min(min, pivot);\n max = Math.max(max, pivot);\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n\n // If an explicit range is specified, promote it to a piecewise interpolator.\n if (range !== undefined) {\n interpolate =\n interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : piecewise(interpolate, range);\n }\n\n // Reverse before normalization.\n if (reverse) interpolate = flip(interpolate);\n\n // Normalize the interpolator for symmetric difference around the pivot.\n if (symmetric) {\n const mid = transform.apply(pivot);\n const mindelta = mid - transform.apply(min);\n const maxdelta = transform.apply(max) - mid;\n if (mindelta < maxdelta) min = transform.invert(mid - maxdelta);\n else if (mindelta > maxdelta) max = transform.invert(mid + mindelta);\n }\n\n scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate);\n if (clamp) scale.clamp(clamp);\n if (nice) scale.nice(nice);\n return {type, domain: [min, max], pivot, interpolate, scale};\n}\n\nexport function createScaleDiverging(key, channels, options) {\n return createScaleD(key, scaleDiverging(), transformIdentity, channels, options);\n}\n\nexport function createScaleDivergingSqrt(key, channels, options) {\n return createScaleDivergingPow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) {\n return createScaleD(key, scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, {\n ...options,\n type: \"diverging-pow\"\n });\n}\n\nexport function createScaleDivergingLog(\n key,\n channels,\n {base = 10, pivot = 1, domain = inferDomain(channels, pivot < 0 ? negative : positive), ...options}\n) {\n return createScaleD(key, scaleDivergingLog().base((base = +base)), transformLog, channels, {\n domain,\n pivot,\n ...options\n });\n}\n\nexport function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleD(\n key,\n scaleDivergingSymlog().constant((constant = +constant)),\n transformSymlog(constant),\n channels,\n options\n );\n}\n\nconst transformIdentity = {\n apply(x) {\n return x;\n },\n invert(x) {\n return x;\n }\n};\n\nconst transformLog = {\n apply: Math.log,\n invert: Math.exp\n};\n\nconst transformSqrt = {\n apply(x) {\n return Math.sign(x) * Math.sqrt(Math.abs(x));\n },\n invert(x) {\n return Math.sign(x) * (x * x);\n }\n};\n\nfunction transformPow(exponent) {\n return exponent === 0.5\n ? transformSqrt\n : {\n apply(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), exponent);\n },\n invert(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent);\n }\n };\n}\n\nfunction transformSymlog(constant) {\n return {\n apply(x) {\n return Math.sign(x) * Math.log1p(Math.abs(x / constant));\n },\n invert(x) {\n return Math.sign(x) * Math.expm1(Math.abs(x)) * constant;\n }\n };\n}\n","import {scaleTime, scaleUtc} from \"d3\";\nimport {createScaleQ} from \"./quantitative.js\";\n\nfunction createScaleT(key, scale, channels, options) {\n return createScaleQ(key, scale, channels, options);\n}\n\nexport function createScaleTime(key, channels, options) {\n return createScaleT(key, scaleTime(), channels, options);\n}\n\nexport function createScaleUtc(key, channels, options) {\n return createScaleT(key, scaleUtc(), channels, options);\n}\n","import {InternSet, extent, quantize, reverse as reverseof, sort, symbolsFill, symbolsStroke} from \"d3\";\nimport {scaleBand, scaleOrdinal, scalePoint, scaleImplicit} from \"d3\";\nimport {ascendingDefined} from \"../defined.js\";\nimport {isNoneish, map, maybeRangeInterval} from \"../options.js\";\nimport {maybeSymbol} from \"../symbol.js\";\nimport {registry, color, position, symbol} from \"./index.js\";\nimport {maybeBooleanRange, ordinalScheme, quantitativeScheme} from \"./schemes.js\";\n\n// This denotes an implicitly ordinal color scale: the scale type was not set,\n// but the associated values are strings or booleans. If the associated defined\n// values are entirely boolean, the range will default to greys. You can opt out\n// of this by setting the type explicitly.\nexport const ordinalImplicit = Symbol(\"ordinal\");\n\nfunction createScaleO(key, scale, channels, {type, interval, domain, range, reverse, hint}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n if (type === \"categorical\" || type === ordinalImplicit) type = \"ordinal\"; // shorthand for color schemes\n if (reverse) domain = reverseof(domain);\n scale.domain(domain);\n if (range !== undefined) {\n // If the range is specified as a function, pass it the domain.\n if (typeof range === \"function\") range = range(domain);\n scale.range(range);\n }\n return {type, domain, range, scale, hint, interval};\n}\n\nexport function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n let hint;\n if (registry.get(key) === symbol) {\n hint = inferSymbolHint(channels);\n range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol);\n } else if (registry.get(key) === color) {\n if (range === undefined && (type === \"ordinal\" || type === ordinalImplicit)) {\n range = maybeBooleanRange(domain, scheme);\n if (range !== undefined) scheme = undefined; // Don’t re-apply scheme.\n }\n if (scheme === undefined && range === undefined) {\n scheme = type === \"ordinal\" ? \"turbo\" : \"tableau10\";\n }\n if (scheme !== undefined) {\n if (range !== undefined) {\n const interpolate = quantitativeScheme(scheme);\n const t0 = range[0],\n d = range[1] - range[0];\n range = ({length: n}) => quantize((t) => interpolate(t0 + d * t), n);\n } else {\n range = ordinalScheme(scheme);\n }\n }\n }\n if (unknown === scaleImplicit) {\n throw new Error(`implicit unknown on ${key} scale is not supported`);\n }\n return createScaleO(key, scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint});\n}\n\nexport function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) {\n return maybeRound(scalePoint().align(align).padding(padding), channels, options, key);\n}\n\nexport function createScaleBand(\n key,\n channels,\n {\n align = 0.5,\n padding = 0.1,\n paddingInner = padding,\n paddingOuter = key === \"fx\" || key === \"fy\" ? 0 : padding,\n ...options\n }\n) {\n return maybeRound(\n scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter),\n channels,\n options,\n key\n );\n}\n\nfunction maybeRound(scale, channels, options, key) {\n let {round} = options;\n if (round !== undefined) scale.round((round = !!round));\n scale = createScaleO(key, scale, channels, options);\n scale.round = round; // preserve for autoScaleRound\n return scale;\n}\n\nfunction inferDomain(channels, interval, key) {\n const values = new InternSet();\n for (const {value, domain} of channels) {\n if (domain !== undefined) return domain(); // see channelDomain\n if (value === undefined) continue;\n for (const v of value) values.add(v);\n }\n if (interval !== undefined) {\n const [min, max] = extent(values).map(interval.floor, interval);\n return interval.range(min, interval.offset(max));\n }\n if (values.size > 10e3 && registry.get(key) === position) {\n throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`);\n }\n return sort(values, ascendingDefined);\n}\n\n// If all channels provide a consistent hint, propagate it to the scale.\nfunction inferHint(channels, key) {\n let value;\n for (const {hint} of channels) {\n const candidate = hint?.[key];\n if (candidate === undefined) continue; // no hint here\n if (value === undefined) value = candidate;\n // first hint\n else if (value !== candidate) return; // inconsistent hint\n }\n return value;\n}\n\nfunction inferSymbolHint(channels) {\n return {\n fill: inferHint(channels, \"fill\"),\n stroke: inferHint(channels, \"stroke\")\n };\n}\n\nfunction inferSymbolRange(hint) {\n return isNoneish(hint.fill) ? symbolsStroke : symbolsFill;\n}\n","import {\n isOrdinal,\n isTemporal,\n isTemporalString,\n isNumericString,\n isScaleOptions,\n map,\n slice,\n coerceNumbers,\n coerceDates\n} from \"./options.js\";\nimport {registry, color, position, radius, opacity, symbol, length} from \"./scales/index.js\";\nimport {\n createScaleLinear,\n createScaleSqrt,\n createScalePow,\n createScaleLog,\n createScaleSymlog,\n createScaleQuantile,\n createScaleQuantize,\n createScaleThreshold,\n createScaleIdentity\n} from \"./scales/quantitative.js\";\nimport {\n createScaleDiverging,\n createScaleDivergingSqrt,\n createScaleDivergingPow,\n createScaleDivergingLog,\n createScaleDivergingSymlog\n} from \"./scales/diverging.js\";\nimport {isDivergingScheme} from \"./scales/schemes.js\";\nimport {createScaleTime, createScaleUtc} from \"./scales/temporal.js\";\nimport {createScaleOrdinal, createScalePoint, createScaleBand, ordinalImplicit} from \"./scales/ordinal.js\";\nimport {maybeSymbol} from \"./symbol.js\";\nimport {warn} from \"./warnings.js\";\n\nexport function createScales(\n channelsByScale,\n {\n label: globalLabel,\n inset: globalInset = 0,\n insetTop: globalInsetTop = globalInset,\n insetRight: globalInsetRight = globalInset,\n insetBottom: globalInsetBottom = globalInset,\n insetLeft: globalInsetLeft = globalInset,\n round,\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n facet: {label: facetLabel = globalLabel} = {},\n ...options\n } = {}\n) {\n const scales = {};\n for (const [key, channels] of channelsByScale) {\n const scaleOptions = options[key];\n const scale = createScale(key, channels, {\n round: registry.get(key) === position ? round : undefined, // only for position\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n ...scaleOptions\n });\n if (scale) {\n // populate generic scale options (percent, transform, insets)\n let {\n label = key === \"fx\" || key === \"fy\" ? facetLabel : globalLabel,\n percent,\n transform,\n inset,\n insetTop = inset !== undefined ? inset : key === \"y\" ? globalInsetTop : 0, // not fy\n insetRight = inset !== undefined ? inset : key === \"x\" ? globalInsetRight : 0, // not fx\n insetBottom = inset !== undefined ? inset : key === \"y\" ? globalInsetBottom : 0, // not fy\n insetLeft = inset !== undefined ? inset : key === \"x\" ? globalInsetLeft : 0 // not fx\n } = scaleOptions || {};\n if (transform == null) transform = undefined;\n else if (typeof transform !== \"function\") throw new Error(\"invalid scale transform; not a function\");\n scale.percent = !!percent;\n scale.label = label === undefined ? inferScaleLabel(channels, scale) : label;\n scale.transform = transform;\n if (key === \"x\" || key === \"fx\") {\n scale.insetLeft = +insetLeft;\n scale.insetRight = +insetRight;\n } else if (key === \"y\" || key === \"fy\") {\n scale.insetTop = +insetTop;\n scale.insetBottom = +insetBottom;\n }\n scales[key] = scale;\n }\n }\n return scales;\n}\n\nexport function createScaleFunctions(scales) {\n return Object.fromEntries(\n Object.entries(scales)\n .filter(([, {scale}]) => scale) // drop identity scales\n .map(([name, {scale, type, interval, label}]) => {\n scale.type = type; // for axis\n if (interval != null) scale.interval = interval; // for axis\n if (label != null) scale.label = label; // for axis\n return [name, scale];\n })\n );\n}\n\n// Mutates scale.range!\nexport function autoScaleRange(scales, dimensions) {\n const {x, y, fx, fy} = scales;\n const superdimensions = fx || fy ? outerDimensions(dimensions) : dimensions;\n if (fx) autoScaleRangeX(fx, superdimensions);\n if (fy) autoScaleRangeY(fy, superdimensions);\n const subdimensions = fx || fy ? innerDimensions(scales, dimensions) : dimensions;\n if (x) autoScaleRangeX(x, subdimensions);\n if (y) autoScaleRangeY(y, subdimensions);\n}\n\n// Channels can have labels; if all the channels for a given scale are\n// consistently labeled (i.e., have the same value if not undefined), and the\n// corresponding scale doesn’t already have an explicit label, then the\n// channels’ label is promoted to the scale. This inferred label should have an\n// orientation-appropriate arrow added when used as an axis, but we don’t want\n// to add the arrow when the label is set explicitly as an option; so, the\n// inferred label is distinguished as an object with an “inferred” property.\nfunction inferScaleLabel(channels = [], scale) {\n let label;\n for (const {label: l} of channels) {\n if (l === undefined) continue;\n if (label === undefined) label = l;\n else if (label !== l) return;\n }\n if (label === undefined) return;\n // Ignore the implicit label for temporal scales if it’s simply “date”.\n if (isTemporalScale(scale) && /^(date|time|year)$/i.test(label)) return;\n if (!isOrdinalScale(scale) && scale.percent) label = `${label} (%)`;\n return {inferred: true, toString: () => label};\n}\n\n// Returns the dimensions of the outer frame; this is subdivided into facets\n// with the margins of each facet collapsing into the outer margins.\nexport function outerDimensions(dimensions) {\n const {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width,\n height,\n facet: {\n marginTop: facetMarginTop,\n marginRight: facetMarginRight,\n marginBottom: facetMarginBottom,\n marginLeft: facetMarginLeft\n }\n } = dimensions;\n return {\n marginTop: Math.max(marginTop, facetMarginTop),\n marginRight: Math.max(marginRight, facetMarginRight),\n marginBottom: Math.max(marginBottom, facetMarginBottom),\n marginLeft: Math.max(marginLeft, facetMarginLeft),\n width,\n height\n };\n}\n\n// Returns the dimensions of each facet.\nexport function innerDimensions({fx, fy}, dimensions) {\n const {marginTop, marginRight, marginBottom, marginLeft, width, height} = outerDimensions(dimensions);\n return {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width: fx ? fx.scale.bandwidth() + marginLeft + marginRight : width,\n height: fy ? fy.scale.bandwidth() + marginTop + marginBottom : height\n };\n}\n\nfunction autoScaleRangeX(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetLeft, insetRight} = scale;\n const {width, marginLeft = 0, marginRight = 0} = dimensions;\n const left = marginLeft + insetLeft;\n const right = width - marginRight - insetRight;\n scale.range = [left, Math.max(left, right)];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRangeY(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetTop, insetBottom} = scale;\n const {height, marginTop = 0, marginBottom = 0} = dimensions;\n const top = marginTop + insetTop;\n const bottom = height - marginBottom - insetBottom;\n scale.range = [Math.max(top, bottom), top];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n else scale.range.reverse();\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRound(scale) {\n if (scale.round === undefined && isBandScale(scale) && roundError(scale) <= 30) {\n scale.scale.round(true);\n }\n}\n\n// If we were to turn on rounding for this band or point scale, how much wasted\n// space would it introduce (on both ends of the range)? This must match\n// d3.scaleBand’s rounding behavior:\n// https://github.com/d3/d3-scale/blob/83555bd759c7314420bd4240642beda5e258db9e/src/band.js#L20-L32\nfunction roundError({scale}) {\n const n = scale.domain().length;\n const [start, stop] = scale.range();\n const paddingInner = scale.paddingInner ? scale.paddingInner() : 1;\n const paddingOuter = scale.paddingOuter ? scale.paddingOuter() : scale.padding();\n const m = n - paddingInner;\n const step = Math.abs(stop - start) / Math.max(1, m + paddingOuter * 2);\n return (step - Math.floor(step)) * m;\n}\n\nfunction piecewiseRange(scale) {\n const length = scale.scale.domain().length + isThresholdScale(scale);\n if (!(length > 2)) return scale.range;\n const [start, end] = scale.range;\n return Array.from({length}, (_, i) => start + (i / (length - 1)) * (end - start));\n}\n\nexport function normalizeScale(key, scale, hint) {\n return createScale(key, hint === undefined ? undefined : [{hint}], {...scale});\n}\n\nfunction createScale(key, channels = [], options = {}) {\n const type = inferScaleType(key, channels, options);\n\n // Warn for common misuses of implicit ordinal scales. We disable this test if\n // you specify a scale interval or if you set the domain or range explicitly,\n // since setting the domain or range (typically with a cardinality of more than\n // two) is another indication that you intended for the scale to be ordinal; we\n // also disable it for facet scales since these are always band scales.\n if (\n options.type === undefined &&\n options.domain === undefined &&\n options.range === undefined &&\n options.interval == null &&\n key !== \"fx\" &&\n key !== \"fy\" &&\n isOrdinalScale({type})\n ) {\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isTemporal))\n warn(\n `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isTemporalString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isNumericString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a \"linear\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n }\n\n options.type = type; // Mutates input!\n\n // Once the scale type is known, coerce the associated channel values and any\n // explicitly-specified domain to the expected type.\n switch (type) {\n case \"diverging\":\n case \"diverging-sqrt\":\n case \"diverging-pow\":\n case \"diverging-log\":\n case \"diverging-symlog\":\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n case \"sqrt\":\n case \"threshold\":\n case \"quantile\":\n case \"pow\":\n case \"log\":\n case \"symlog\":\n options = coerceType(channels, options, coerceNumbers);\n break;\n case \"identity\":\n switch (registry.get(key)) {\n case position:\n options = coerceType(channels, options, coerceNumbers);\n break;\n case symbol:\n options = coerceType(channels, options, coerceSymbols);\n break;\n }\n break;\n case \"utc\":\n case \"time\":\n options = coerceType(channels, options, coerceDates);\n break;\n }\n\n switch (type) {\n case \"diverging\":\n return createScaleDiverging(key, channels, options);\n case \"diverging-sqrt\":\n return createScaleDivergingSqrt(key, channels, options);\n case \"diverging-pow\":\n return createScaleDivergingPow(key, channels, options);\n case \"diverging-log\":\n return createScaleDivergingLog(key, channels, options);\n case \"diverging-symlog\":\n return createScaleDivergingSymlog(key, channels, options);\n case \"categorical\":\n case \"ordinal\":\n case ordinalImplicit:\n return createScaleOrdinal(key, channels, options);\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n return createScaleLinear(key, channels, options);\n case \"sqrt\":\n return createScaleSqrt(key, channels, options);\n case \"threshold\":\n return createScaleThreshold(key, channels, options);\n case \"quantile\":\n return createScaleQuantile(key, channels, options);\n case \"quantize\":\n return createScaleQuantize(key, channels, options);\n case \"pow\":\n return createScalePow(key, channels, options);\n case \"log\":\n return createScaleLog(key, channels, options);\n case \"symlog\":\n return createScaleSymlog(key, channels, options);\n case \"utc\":\n return createScaleUtc(key, channels, options);\n case \"time\":\n return createScaleTime(key, channels, options);\n case \"point\":\n return createScalePoint(key, channels, options);\n case \"band\":\n return createScaleBand(key, channels, options);\n case \"identity\":\n return registry.get(key) === position ? createScaleIdentity() : {type: \"identity\"};\n case undefined:\n return;\n default:\n throw new Error(`unknown scale type: ${type}`);\n }\n}\n\nfunction formatScaleType(type) {\n return typeof type === \"symbol\" ? type.description : type;\n}\n\n// A special type symbol when the x and y scales are replaced with a projection.\nconst typeProjection = {toString: () => \"projection\"};\n\nfunction inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) {\n // The facet scales are always band scales; this cannot be changed.\n if (key === \"fx\" || key === \"fy\") return \"band\";\n\n // If a projection is specified, the x- and y-scales are disabled; these\n // channels will be projected rather than scaled. (But still check that none\n // of the associated channels are incompatible with a projection.)\n if ((key === \"x\" || key === \"y\") && projection != null) type = typeProjection;\n\n // If a channel dictates a scale type, make sure that it is consistent with\n // the user-specified scale type (if any) and all other channels. For example,\n // barY requires x to be a band scale and disallows any other scale type.\n for (const {type: t} of channels) {\n if (t === undefined) continue;\n else if (type === undefined) type = t;\n else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`);\n }\n\n // If the scale, a channel, or user specified a (consistent) type, return it.\n if (type === typeProjection) return;\n if (type !== undefined) return type;\n\n // If there’s no data (and no type) associated with this scale, don’t create a scale.\n if (domain === undefined && !channels.some(({value}) => value !== undefined)) return;\n\n // Some scales have default types.\n const kind = registry.get(key);\n if (kind === radius) return \"sqrt\";\n if (kind === opacity || kind === length) return \"linear\";\n if (kind === symbol) return \"ordinal\";\n\n // If the domain or range has more than two values, assume it’s ordinal. You\n // can still use a “piecewise” (or “polylinear”) scale, but you must set the\n // type explicitly.\n if ((domain || range || []).length > 2) return asOrdinalType(kind);\n\n // Otherwise, infer the scale type from the data! Prefer the domain, if\n // present, over channels. (The domain and channels should be consistently\n // typed, and the domain is more explicit and typically much smaller.) We only\n // check the first defined value for expedience and simplicity; we expect\n // that the types are consistent.\n if (domain !== undefined) {\n if (isOrdinal(domain)) return asOrdinalType(kind);\n if (isTemporal(domain)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n }\n\n // If any channel is ordinal or temporal, it takes priority.\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isOrdinal)) return asOrdinalType(kind);\n if (values.some(isTemporal)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n}\n\n// Positional scales default to a point scale instead of an ordinal scale.\nfunction asOrdinalType(kind) {\n switch (kind) {\n case position:\n return \"point\";\n case color:\n return ordinalImplicit;\n default:\n return \"ordinal\";\n }\n}\n\nexport function isTemporalScale({type}) {\n return type === \"time\" || type === \"utc\";\n}\n\nexport function isOrdinalScale({type}) {\n return type === \"ordinal\" || type === \"point\" || type === \"band\" || type === ordinalImplicit;\n}\n\nexport function isThresholdScale({type}) {\n return type === \"threshold\";\n}\n\nfunction isBandScale({type}) {\n return type === \"point\" || type === \"band\";\n}\n\nexport function isDivergingScale({type}) {\n return /^diverging($|-)/.test(type);\n}\n\n// Certain marks have special behavior if a scale is collapsed, i.e. if the\n// domain is degenerate and represents only a single value such as [3, 3]; for\n// example, a rect will span the full extent of the chart along a collapsed\n// dimension (whereas a dot will simply be drawn in the center).\nexport function isCollapsed(scale) {\n if (scale === undefined) return true; // treat missing scale as collapsed\n const domain = scale.domain();\n const value = scale(domain[0]);\n for (let i = 1, n = domain.length; i < n; ++i) {\n if (scale(domain[i]) - value) {\n return false;\n }\n }\n return true;\n}\n\n// Mutates channel.value!\nfunction coerceType(channels, {domain, ...options}, coerceValues) {\n for (const c of channels) {\n if (c.value !== undefined) {\n c.value = coerceValues(c.value);\n }\n }\n return {\n domain: domain === undefined ? domain : coerceValues(domain),\n ...options\n };\n}\n\nfunction coerceSymbols(values) {\n return map(values, maybeSymbol);\n}\n\nexport function scale(options = {}) {\n let scale;\n for (const key in options) {\n if (!registry.has(key)) continue; // ignore unknown properties\n if (!isScaleOptions(options[key])) continue; // e.g., ignore {color: \"red\"}\n if (scale !== undefined) throw new Error(\"ambiguous scale definition; multiple scales found\");\n scale = exposeScale(normalizeScale(key, options[key]));\n }\n if (scale === undefined) throw new Error(\"invalid scale definition; no scale found\");\n return scale;\n}\n\nexport function exposeScales(scaleDescriptors) {\n return (key) => {\n if (!registry.has((key = `${key}`))) throw new Error(`unknown scale: ${key}`);\n return key in scaleDescriptors ? exposeScale(scaleDescriptors[key]) : undefined;\n };\n}\n\n// Note: axis- and legend-related properties (such as label, ticks and\n// tickFormat) are not included here as they do not affect the scale’s behavior.\nfunction exposeScale({scale, type, domain, range, interpolate, interval, transform, percent, pivot}) {\n if (type === \"identity\") return {type: \"identity\", apply: (d) => d, invert: (d) => d};\n const unknown = scale.unknown ? scale.unknown() : undefined;\n return {\n type,\n domain: slice(domain), // defensive copy\n ...(range !== undefined && {range: slice(range)}), // defensive copy\n ...(transform !== undefined && {transform}),\n ...(percent && {percent}), // only exposed if truthy\n ...(unknown !== undefined && {unknown}),\n ...(interval !== undefined && {interval}),\n\n // quantitative\n ...(interpolate !== undefined && {interpolate}),\n ...(scale.clamp && {clamp: scale.clamp()}),\n\n // diverging (always asymmetric; we never want to apply the symmetric transform twice)\n ...(pivot !== undefined && {pivot, symmetric: false}),\n\n // log, diverging-log\n ...(scale.base && {base: scale.base()}),\n\n // pow, diverging-pow\n ...(scale.exponent && {exponent: scale.exponent()}),\n\n // symlog, diverging-symlog\n ...(scale.constant && {constant: scale.constant()}),\n\n // band, point\n ...(scale.align && {align: scale.align(), round: scale.round()}),\n ...(scale.padding &&\n (scale.paddingInner\n ? {paddingInner: scale.paddingInner(), paddingOuter: scale.paddingOuter()}\n : {padding: scale.padding()})),\n ...(scale.bandwidth && {bandwidth: scale.bandwidth(), step: scale.step()}),\n\n // utilities\n apply: (t) => scale(t),\n ...(scale.invert && {invert: (t) => scale.invert(t)})\n };\n}\n","export enum ScrollDirection {\n SCROLL_NONE,\n SCROLL_BACKWARD,\n SCROLL_FORWARD,\n}\n\nexport enum Position {\n TOP,\n RIGHT,\n BOTTOM,\n LEFT,\n}\n\nexport const OPTIONS_DEFAULT_DOMAIN_TYPE = 'hour';\n\nexport const OPTIONS_DEFAULT_SUBDOMAIN_TYPE = 'minute';\nexport const OPTIONS_DEFAULT_SUBDOMAIN_WIDTH = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_GUTTER = 2;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_RADIUS = 0;\nexport const OPTIONS_DEFAULT_ANIMATION_DURATION = 200;\nexport const OPTIONS_DEFAULT_RANGE = 12;\nexport const OPTIONS_DEFAULT_ITEM_SELECTOR = '#cal-heatmap';\nexport const OPTIONS_DEFAULT_THEME = 'light';\nexport const OPTIONS_DEFAULT_LOCALE = 'en';\n\nexport const SCALE_BASE_OPACITY_COLOR = 'red';\nexport const SCALE_BASE_COLOR_SCHEME = 'YlOrBr';\nexport const SCALE_BASE_COLOR_TYPE = 'quantize';\nexport const SCALE_BASE_COLOR_DOMAIN = [0, 100];\n","// @ts-ignore\nimport { scale } from '@observablehq/plot';\nimport { OptionsType } from './options/Options';\nimport { SCALE_BASE_OPACITY_COLOR } from './constant';\n\nimport type { SubDomain } from './index';\n\ntype ValueType = string | number | undefined;\n\nexport function normalizedScale(scaleOptions: OptionsType['scale']): any {\n try {\n const scaleType = Object.keys(scaleOptions!)[0];\n\n return scale({\n [scaleType]: {\n ...scaleOptions![scaleType as 'color' | 'opacity'],\n clamp: true,\n },\n });\n } catch (error) {\n return null;\n }\n}\n\nfunction scaleStyle(_scale: any, scaleOptions: OptionsType['scale']) {\n const styles: { fill?: Function; 'fill-opacity'?: Function } = {};\n\n if (scaleOptions!.hasOwnProperty('opacity')) {\n styles.fill = () =>\n // eslint-disable-next-line implicit-arrow-linebreak\n scaleOptions!.opacity!.baseColor || SCALE_BASE_OPACITY_COLOR;\n styles['fill-opacity'] = (d: ValueType) => _scale?.apply(d);\n } else {\n styles.fill = (d: ValueType) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n (typeof d === 'string' && d?.startsWith('#') ? d : _scale?.apply(d));\n }\n\n return styles;\n}\n\nexport function applyScaleStyle(\n elem: any,\n _scale: any,\n scaleOptions: OptionsType['scale'],\n keyname?: string,\n) {\n Object.entries(scaleStyle(_scale, scaleOptions)).forEach(([prop, val]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n elem.style(prop, (d: SubDomain | string) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n val(keyname ? (d as SubDomain)[keyname as keyof SubDomain] : d)));\n}\n","'use strict';\nvar $TypeError = TypeError;\nvar MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991\n\nmodule.exports = function (it) {\n if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');\n return it;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar isArray = require('../internals/is-array');\nvar isObject = require('../internals/is-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');\nvar createProperty = require('../internals/create-property');\nvar arraySpeciesCreate = require('../internals/array-species-create');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');\n\n// We can't use this feature detection in V8 since it causes\n// deoptimization and serious performance degradation\n// https://github.com/zloirock/core-js/issues/679\nvar IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {\n var array = [];\n array[IS_CONCAT_SPREADABLE] = false;\n return array.concat()[0] !== array;\n});\n\nvar isConcatSpreadable = function (O) {\n if (!isObject(O)) return false;\n var spreadable = O[IS_CONCAT_SPREADABLE];\n return spreadable !== undefined ? !!spreadable : isArray(O);\n};\n\nvar FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat');\n\n// `Array.prototype.concat` method\n// https://tc39.es/ecma262/#sec-array.prototype.concat\n// with adding support of @@isConcatSpreadable and @@species\n$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n concat: function concat(arg) {\n var O = toObject(this);\n var A = arraySpeciesCreate(O, 0);\n var n = 0;\n var i, k, length, len, E;\n for (i = -1, length = arguments.length; i < length; i++) {\n E = i === -1 ? O : arguments[i];\n if (isConcatSpreadable(E)) {\n len = lengthOfArrayLike(E);\n doesNotExceedSafeInteger(n + len);\n for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);\n } else {\n doesNotExceedSafeInteger(n + 1);\n createProperty(A, n++, E);\n }\n }\n A.length = n;\n return A;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-promise.allsettled\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n allSettled: function allSettled(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call(promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = { status: 'fulfilled', value: value };\n --remaining || resolve(values);\n }, function (error) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = { status: 'rejected', reason: error };\n --remaining || resolve(values);\n });\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar create = require('../internals/object-create');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n index: create(null),\n first: undefined,\n last: undefined,\n size: 0\n });\n if (!DESCRIPTORS) that.size = 0;\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n var previous, index;\n // change existing entry\n if (entry) {\n entry.value = value;\n // create new entry\n } else {\n state.last = entry = {\n index: index = fastKey(key, true),\n key: key,\n value: value,\n previous: previous = state.last,\n next: undefined,\n removed: false\n };\n if (!state.first) state.first = entry;\n if (previous) previous.next = entry;\n if (DESCRIPTORS) state.size++;\n else that.size++;\n // add to index\n if (index !== 'F') state.index[index] = entry;\n } return that;\n };\n\n var getEntry = function (that, key) {\n var state = getInternalState(that);\n // fast case\n var index = fastKey(key);\n var entry;\n if (index !== 'F') return state.index[index];\n // frozen object case\n for (entry = state.first; entry; entry = entry.next) {\n if (entry.key === key) return entry;\n }\n };\n\n defineBuiltIns(Prototype, {\n // `{ Map, Set }.prototype.clear()` methods\n // https://tc39.es/ecma262/#sec-map.prototype.clear\n // https://tc39.es/ecma262/#sec-set.prototype.clear\n clear: function clear() {\n var that = this;\n var state = getInternalState(that);\n var data = state.index;\n var entry = state.first;\n while (entry) {\n entry.removed = true;\n if (entry.previous) entry.previous = entry.previous.next = undefined;\n delete data[entry.index];\n entry = entry.next;\n }\n state.first = state.last = undefined;\n if (DESCRIPTORS) state.size = 0;\n else that.size = 0;\n },\n // `{ Map, Set }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.delete\n // https://tc39.es/ecma262/#sec-set.prototype.delete\n 'delete': function (key) {\n var that = this;\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n if (entry) {\n var next = entry.next;\n var prev = entry.previous;\n delete state.index[entry.index];\n entry.removed = true;\n if (prev) prev.next = next;\n if (next) next.previous = prev;\n if (state.first === entry) state.first = next;\n if (state.last === entry) state.last = prev;\n if (DESCRIPTORS) state.size--;\n else that.size--;\n } return !!entry;\n },\n // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.foreach\n // https://tc39.es/ecma262/#sec-set.prototype.foreach\n forEach: function forEach(callbackfn /* , that = undefined */) {\n var state = getInternalState(this);\n var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n var entry;\n while (entry = entry ? entry.next : state.first) {\n boundFunction(entry.value, entry.key, this);\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n }\n },\n // `{ Map, Set}.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.has\n // https://tc39.es/ecma262/#sec-set.prototype.has\n has: function has(key) {\n return !!getEntry(this, key);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `Map.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-map.prototype.get\n get: function get(key) {\n var entry = getEntry(this, key);\n return entry && entry.value;\n },\n // `Map.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-map.prototype.set\n set: function set(key, value) {\n return define(this, key === 0 ? 0 : key, value);\n }\n } : {\n // `Set.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-set.prototype.add\n add: function add(value) {\n return define(this, value = value === 0 ? 0 : value, value);\n }\n });\n if (DESCRIPTORS) defineBuiltInAccessor(Prototype, 'size', {\n configurable: true,\n get: function () {\n return getInternalState(this).size;\n }\n });\n return Constructor;\n },\n setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {\n var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods\n // https://tc39.es/ecma262/#sec-map.prototype.entries\n // https://tc39.es/ecma262/#sec-map.prototype.keys\n // https://tc39.es/ecma262/#sec-map.prototype.values\n // https://tc39.es/ecma262/#sec-map.prototype-@@iterator\n // https://tc39.es/ecma262/#sec-set.prototype.entries\n // https://tc39.es/ecma262/#sec-set.prototype.keys\n // https://tc39.es/ecma262/#sec-set.prototype.values\n // https://tc39.es/ecma262/#sec-set.prototype-@@iterator\n defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {\n setInternalState(this, {\n type: ITERATOR_NAME,\n target: iterated,\n state: getInternalCollectionState(iterated),\n kind: kind,\n last: undefined\n });\n }, function () {\n var state = getInternalIteratorState(this);\n var kind = state.kind;\n var entry = state.last;\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n // get next entry\n if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n // or finish the iteration\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n // return step by kind\n if (kind === 'keys') return createIterResultObject(entry.key, false);\n if (kind === 'values') return createIterResultObject(entry.value, false);\n return createIterResultObject([entry.key, entry.value], false);\n }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n // `{ Map, Set }.prototype[@@species]` accessors\n // https://tc39.es/ecma262/#sec-get-map-@@species\n // https://tc39.es/ecma262/#sec-get-set-@@species\n setSpecies(CONSTRUCTOR_NAME);\n }\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.es/ecma262/#sec-map-objects\ncollection('Map', function (init) {\n return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","'use strict';\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (O, P) {\n if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));\n};\n","'use strict';\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar floor = Math.floor;\n\nvar mergeSort = function (array, comparefn) {\n var length = array.length;\n var middle = floor(length / 2);\n return length < 8 ? insertionSort(array, comparefn) : merge(\n array,\n mergeSort(arraySlice(array, 0, middle), comparefn),\n mergeSort(arraySlice(array, middle), comparefn),\n comparefn\n );\n};\n\nvar insertionSort = function (array, comparefn) {\n var length = array.length;\n var i = 1;\n var element, j;\n\n while (i < length) {\n j = i;\n element = array[i];\n while (j && comparefn(array[j - 1], element) > 0) {\n array[j] = array[--j];\n }\n if (j !== i++) array[j] = element;\n } return array;\n};\n\nvar merge = function (array, left, right, comparefn) {\n var llength = left.length;\n var rlength = right.length;\n var lindex = 0;\n var rindex = 0;\n\n while (lindex < llength || rindex < rlength) {\n array[lindex + rindex] = (lindex < llength && rindex < rlength)\n ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]\n : lindex < llength ? left[lindex++] : right[rindex++];\n } return array;\n};\n\nmodule.exports = mergeSort;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nvar firefox = userAgent.match(/firefox\\/(\\d+)/i);\n\nmodule.exports = !!firefox && +firefox[1];\n","'use strict';\nvar UA = require('../internals/engine-user-agent');\n\nmodule.exports = /MSIE|Trident/.test(UA);\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nvar webkit = userAgent.match(/AppleWebKit\\/(\\d+)\\./);\n\nmodule.exports = !!webkit && +webkit[1];\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar deletePropertyOrThrow = require('../internals/delete-property-or-throw');\nvar toString = require('../internals/to-string');\nvar fails = require('../internals/fails');\nvar internalSort = require('../internals/array-sort');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\nvar FF = require('../internals/engine-ff-version');\nvar IE_OR_EDGE = require('../internals/engine-is-ie-or-edge');\nvar V8 = require('../internals/engine-v8-version');\nvar WEBKIT = require('../internals/engine-webkit-version');\n\nvar test = [];\nvar nativeSort = uncurryThis(test.sort);\nvar push = uncurryThis(test.push);\n\n// IE8-\nvar FAILS_ON_UNDEFINED = fails(function () {\n test.sort(undefined);\n});\n// V8 bug\nvar FAILS_ON_NULL = fails(function () {\n test.sort(null);\n});\n// Old WebKit\nvar STRICT_METHOD = arrayMethodIsStrict('sort');\n\nvar STABLE_SORT = !fails(function () {\n // feature detection can be too slow, so check engines versions\n if (V8) return V8 < 70;\n if (FF && FF > 3) return;\n if (IE_OR_EDGE) return true;\n if (WEBKIT) return WEBKIT < 603;\n\n var result = '';\n var code, chr, value, index;\n\n // generate an array with more 512 elements (Chakra and old V8 fails only in this case)\n for (code = 65; code < 76; code++) {\n chr = String.fromCharCode(code);\n\n switch (code) {\n case 66: case 69: case 70: case 72: value = 3; break;\n case 68: case 71: value = 4; break;\n default: value = 2;\n }\n\n for (index = 0; index < 47; index++) {\n test.push({ k: chr + index, v: value });\n }\n }\n\n test.sort(function (a, b) { return b.v - a.v; });\n\n for (index = 0; index < test.length; index++) {\n chr = test[index].k.charAt(0);\n if (result.charAt(result.length - 1) !== chr) result += chr;\n }\n\n return result !== 'DGBEFHACIJK';\n});\n\nvar FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;\n\nvar getSortCompare = function (comparefn) {\n return function (x, y) {\n if (y === undefined) return -1;\n if (x === undefined) return 1;\n if (comparefn !== undefined) return +comparefn(x, y) || 0;\n return toString(x) > toString(y) ? 1 : -1;\n };\n};\n\n// `Array.prototype.sort` method\n// https://tc39.es/ecma262/#sec-array.prototype.sort\n$({ target: 'Array', proto: true, forced: FORCED }, {\n sort: function sort(comparefn) {\n if (comparefn !== undefined) aCallable(comparefn);\n\n var array = toObject(this);\n\n if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn);\n\n var items = [];\n var arrayLength = lengthOfArrayLike(array);\n var itemsLength, index;\n\n for (index = 0; index < arrayLength; index++) {\n if (index in array) push(items, array[index]);\n }\n\n internalSort(items, getSortCompare(comparefn));\n\n itemsLength = lengthOfArrayLike(items);\n index = 0;\n\n while (index < itemsLength) array[index] = items[index++];\n while (index < arrayLength) deletePropertyOrThrow(array, index++);\n\n return array;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar $includes = require('../internals/array-includes').includes;\nvar fails = require('../internals/fails');\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// FF99+ bug\nvar BROKEN_ON_SPARSE = fails(function () {\n // eslint-disable-next-line es/no-array-prototype-includes -- detection\n return !Array(1).includes();\n});\n\n// `Array.prototype.includes` method\n// https://tc39.es/ecma262/#sec-array.prototype.includes\n$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {\n includes: function includes(el /* , fromIndex = 0 */) {\n return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('includes');\n","'use strict';\nvar $ = require('../internals/export');\nvar $map = require('../internals/array-iteration').map;\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');\n\n// `Array.prototype.map` method\n// https://tc39.es/ecma262/#sec-array.prototype.map\n// with adding support of @@species\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n map: function map(callbackfn /* , thisArg */) {\n return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar $filter = require('../internals/array-iteration').filter;\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter');\n\n// `Array.prototype.filter` method\n// https://tc39.es/ecma262/#sec-array.prototype.filter\n// with adding support of @@species\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n filter: function filter(callbackfn /* , thisArg */) {\n return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar iteratorClose = require('../internals/iterator-close');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n try {\n return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar toObject = require('../internals/to-object');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar isConstructor = require('../internals/is-constructor');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $Array = Array;\n\n// `Array.from` method implementation\n// https://tc39.es/ecma262/#sec-array.from\nmodule.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n var O = toObject(arrayLike);\n var IS_CONSTRUCTOR = isConstructor(this);\n var argumentsLength = arguments.length;\n var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n var mapping = mapfn !== undefined;\n if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);\n var iteratorMethod = getIteratorMethod(O);\n var index = 0;\n var length, result, step, iterator, next, value;\n // if the target is not iterable or it's an array with the default iterator - use a simple case\n if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) {\n iterator = getIterator(O, iteratorMethod);\n next = iterator.next;\n result = IS_CONSTRUCTOR ? new this() : [];\n for (;!(step = call(next, iterator)).done; index++) {\n value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;\n createProperty(result, index, value);\n }\n } else {\n length = lengthOfArrayLike(O);\n result = IS_CONSTRUCTOR ? new this(length) : $Array(length);\n for (;length > index; index++) {\n value = mapping ? mapfn(O[index], index) : O[index];\n createProperty(result, index, value);\n }\n }\n result.length = index;\n return result;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar from = require('../internals/array-from');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\n\nvar INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {\n // eslint-disable-next-line es/no-array-from -- required for testing\n Array.from(iterable);\n});\n\n// `Array.from` method\n// https://tc39.es/ecma262/#sec-array.from\n$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {\n from: from\n});\n","'use strict';\n// a string of all valid unicode whitespaces\nmodule.exports = '\\u0009\\u000A\\u000B\\u000C\\u000D\\u0020\\u00A0\\u1680\\u2000\\u2001\\u2002' +\n '\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\nvar whitespaces = require('../internals/whitespaces');\n\nvar replace = uncurryThis(''.replace);\nvar ltrim = RegExp('^[' + whitespaces + ']+');\nvar rtrim = RegExp('(^|[^' + whitespaces + '])[' + whitespaces + ']+$');\n\n// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation\nvar createMethod = function (TYPE) {\n return function ($this) {\n var string = toString(requireObjectCoercible($this));\n if (TYPE & 1) string = replace(string, ltrim, '');\n if (TYPE & 2) string = replace(string, rtrim, '$1');\n return string;\n };\n};\n\nmodule.exports = {\n // `String.prototype.{ trimLeft, trimStart }` methods\n // https://tc39.es/ecma262/#sec-string.prototype.trimstart\n start: createMethod(1),\n // `String.prototype.{ trimRight, trimEnd }` methods\n // https://tc39.es/ecma262/#sec-string.prototype.trimend\n end: createMethod(2),\n // `String.prototype.trim` method\n // https://tc39.es/ecma262/#sec-string.prototype.trim\n trim: createMethod(3)\n};\n","'use strict';\nvar PROPER_FUNCTION_NAME = require('../internals/function-name').PROPER;\nvar fails = require('../internals/fails');\nvar whitespaces = require('../internals/whitespaces');\n\nvar non = '\\u200B\\u0085\\u180E';\n\n// check that a method works with the correct list\n// of whitespaces and has a correct name\nmodule.exports = function (METHOD_NAME) {\n return fails(function () {\n return !!whitespaces[METHOD_NAME]()\n || non[METHOD_NAME]() !== non\n || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME);\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $trim = require('../internals/string-trim').trim;\nvar forcedStringTrimMethod = require('../internals/string-trim-forced');\n\n// `String.prototype.trim` method\n// https://tc39.es/ecma262/#sec-string.prototype.trim\n$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {\n trim: function trim() {\n return $trim(this);\n }\n});\n","import { Position } from '../constant';\nimport type CalHeatmap from '../CalHeatmap';\nimport type { Timestamp, SubDomain } from '../index';\n\nexport const DEFAULT_SELECTOR = '.ch-subdomain';\nconst HIGHLIGHT_CLASSNAME = 'highlight';\n\nexport default class SubDomainPainter {\n calendar: CalHeatmap;\n\n root: any;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.root = null;\n }\n\n paint(root: any): void {\n this.root = root || this.root;\n const containerClassname = `${DEFAULT_SELECTOR}-container`;\n\n const subDomainSvgGroup = this.root\n .selectAll(containerClassname)\n .data(\n (d: Timestamp) => [d],\n (d: Timestamp) => d,\n )\n .join(\n (enter: any) => enter\n .append('svg')\n .call((selection: any) => this.#setPositions(selection))\n .attr('class', containerClassname.slice(1)),\n\n (update: any) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n update.call((selection: any) => this.#setPositions(selection)),\n );\n\n const {\n subDomain: {\n radius, width, height, sort,\n },\n } = this.calendar.options.options;\n const evt = this.calendar.eventEmitter;\n\n subDomainSvgGroup\n .selectAll('g')\n .data((d: Timestamp) => {\n const subDomainsCollection: SubDomain[] =\n this.calendar.domainCollection.get(d)!;\n if (sort === 'desc') {\n const max = Math.max(\n ...subDomainsCollection.map((s: SubDomain) => s.x),\n );\n subDomainsCollection.forEach((s: SubDomain, i: number) => {\n subDomainsCollection[i].x = Math.abs(s.x - max);\n });\n }\n\n return subDomainsCollection;\n })\n .join(\n (enter: any) => enter\n .append('g')\n .call((selection: any) => selection\n .insert('rect')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-bg`))\n .attr('width', width)\n .attr('height', height)\n .attr('x', (d: SubDomain) => this.#getX(d))\n .attr('y', (d: SubDomain) => this.#getY(d))\n .on('click', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('click', ev, d.t, d.v))\n .on('mouseover', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('mouseover', ev, d.t, d.v))\n .on('mouseout', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('mouseout', ev, d.t, d.v))\n .attr('rx', radius > 0 ? radius : null)\n .attr('ry', radius > 0 ? radius : null))\n .call((selection: any) => this.#appendText(selection)),\n (update: any) => update\n .selectAll('rect')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-bg`))\n .attr('width', width)\n .attr('height', height)\n .attr('x', (d: SubDomain) => this.#getX(d))\n .attr('y', (d: SubDomain) => this.#getY(d))\n .attr('rx', radius)\n .attr('ry', radius),\n );\n }\n\n /**\n * Set the subDomain group X and Y position\n * @param {d3-selection} selection A d3-selection object\n */\n #setPositions(selection: any): void {\n const { options } = this.calendar.options;\n const {\n padding,\n label: { position },\n } = options.domain;\n\n selection\n .attr('x', () => {\n let pos = padding[Position.LEFT];\n if (position === 'left') {\n pos += options.x.domainHorizontalLabelWidth;\n }\n return pos;\n })\n .attr('y', () => {\n let pos = padding[Position.TOP];\n if (position === 'top') {\n pos += options.x.domainVerticalLabelHeight;\n }\n return pos;\n });\n }\n\n /**\n * Return a classname if the specified date should be highlighted\n *\n * @param {number} timestamp Unix timestamp of the current subDomain\n * @return {String} the highlight class\n */\n #classname(timestamp: Timestamp, ...otherClasses: string[]): string {\n const {\n date: { highlight },\n subDomain: { type },\n } = this.calendar.options.options;\n let classname = '';\n\n if (highlight.length > 0) {\n highlight.forEach((d) => {\n const unitFn = this.calendar.templateCollection.get(type).extractUnit;\n\n if (unitFn(+d) === unitFn(timestamp)) {\n classname = HIGHLIGHT_CLASSNAME;\n }\n });\n }\n\n return [classname, ...otherClasses].join(' ').trim();\n }\n\n #appendText(elem: any) {\n const { width, height, label } = this.calendar.options.options.subDomain;\n\n if (!label) {\n return null;\n }\n\n return elem\n .append('text')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-text`))\n .attr('x', (d: SubDomain) => this.#getX(d) + width / 2)\n .attr('y', (d: SubDomain) => this.#getY(d) + height / 2)\n .attr('text-anchor', 'middle')\n .attr('dominant-baseline', 'central')\n .text((d: SubDomain, i: number, nodes: any[]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.calendar.dateHelper.format(d.t, label, d.v, nodes[i]));\n }\n\n #getCoordinates(axis: 'x' | 'y', d: SubDomain): number {\n const { subDomain } = this.calendar.options.options;\n return (\n d[axis] *\n (subDomain[axis === 'x' ? 'width' : 'height'] + subDomain.gutter)\n );\n }\n\n #getX(d: SubDomain): number {\n return this.#getCoordinates('x', d);\n }\n\n #getY(d: SubDomain): number {\n return this.#getCoordinates('y', d);\n }\n}\n","import { select, create } from 'd3-selection';\nimport { normalizedScale, applyScaleStyle } from '../scale';\nimport { DEFAULT_SELECTOR as MAIN_SELECTOR } from '../calendar/CalendarPainter';\nimport {\n // force line break from prettier\n DEFAULT_SELECTOR as SUBDOMAIN_SELECTOR,\n} from '../subDomain/SubDomainPainter';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { IPlugin, PluginOptions } from '../index';\nimport {\n OPTIONS_DEFAULT_SUBDOMAIN_WIDTH,\n OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT,\n OPTIONS_DEFAULT_SUBDOMAIN_GUTTER,\n OPTIONS_DEFAULT_SUBDOMAIN_RADIUS,\n} from '../constant';\n\ninterface LegendOptions extends PluginOptions {\n enabled: boolean;\n itemSelector: string | null;\n width: number;\n height: number;\n radius: number;\n gutter: number;\n includeBlank: boolean;\n}\n\nconst DEFAULT_SELECTOR = '.ch-plugin-legend-lite';\n\nconst defaultOptions: LegendOptions = {\n enabled: true, // Whether to display the legend\n itemSelector: null,\n width: OPTIONS_DEFAULT_SUBDOMAIN_WIDTH,\n height: OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT,\n gutter: OPTIONS_DEFAULT_SUBDOMAIN_GUTTER,\n radius: OPTIONS_DEFAULT_SUBDOMAIN_RADIUS,\n includeBlank: false,\n};\n\nexport default class LegendLite implements IPlugin {\n name = 'LegendLite';\n\n calendar: CalHeatmap;\n\n root: any;\n\n shown: boolean;\n\n options: LegendOptions;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.root = null;\n this.shown = false;\n this.options = defaultOptions;\n }\n\n setup(pluginOptions?: Partial): void {\n this.options = { ...this.options, ...pluginOptions };\n }\n\n paint(): Promise {\n const { enabled, itemSelector } = this.options;\n\n if (!enabled || (itemSelector && select(itemSelector).empty())) {\n return this.destroy();\n }\n\n this.shown = true;\n\n this.root = select(\n itemSelector || this.calendar.options.options.itemSelector,\n );\n\n if (this.root.select(DEFAULT_SELECTOR).empty()) {\n this.root = this.root\n .append('div')\n .attr('class', DEFAULT_SELECTOR.slice(1));\n } else {\n this.root = this.root.select(DEFAULT_SELECTOR);\n }\n\n const node = this.#buildLegend();\n\n this.root.selectAll('*').remove();\n this.root.append(() => node.node());\n\n return Promise.resolve();\n }\n\n destroy(): Promise {\n if (this.root !== null) {\n this.root.remove();\n this.root = null;\n }\n\n return Promise.resolve();\n }\n\n #buildLegend() {\n const node = create('svg');\n const scale = normalizedScale(this.calendar.options.options.scale);\n const {\n width, height, gutter, includeBlank,\n } = this.options;\n\n const localRange = [...scale.range];\n if (includeBlank) {\n localRange.unshift(null);\n }\n\n node\n .attr('class', MAIN_SELECTOR.slice(1))\n .attr(\n 'width',\n localRange.length * width + (localRange.length - 1) * gutter,\n )\n .attr('height', height);\n\n node\n .selectAll('rect')\n .data(localRange)\n .join(\n (enter: any) => enter.append('rect').call((sc: any) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#nodeAttrs(sc, scale)),\n (update: any) => update\n .selectAll('rect')\n .call((sc: any) => this.#nodeAttrs(sc, scale)),\n );\n\n return node;\n }\n\n #nodeAttrs(selection: any, scale: any) {\n const {\n width, height, radius, gutter,\n } = this.options;\n\n return selection\n .attr('width', width)\n .attr('height', height)\n .attr('class', `${SUBDOMAIN_SELECTOR.slice(1)}-bg`)\n .attr('rx', radius)\n .attr('ry', radius)\n .attr('x', (_d: any, i: number) => i * (width + gutter))\n .attr('y', 0)\n .call((element: any) => {\n applyScaleStyle(element, scale, this.calendar.options.options.scale!);\n });\n }\n}\n","import { select } from 'd3-selection';\n\nimport DomainsContainerPainter from '../domain/DomainsContainerPainter';\nimport PluginPainter from '../plugins/PluginPainter';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport { ScrollDirection } from '../constant';\nimport type { Dimensions } from '../index';\n\nexport const DEFAULT_SELECTOR = '.ch-container';\n\nexport default class CalendarPainter {\n calendar: CalHeatmap;\n\n dimensions: Dimensions;\n\n root: any;\n\n domainsContainerPainter: DomainsContainerPainter;\n\n pluginPainter: PluginPainter;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.dimensions = {\n width: 0,\n height: 0,\n };\n this.root = null;\n this.domainsContainerPainter = new DomainsContainerPainter(calendar);\n this.pluginPainter = new PluginPainter(calendar);\n }\n\n setup(): boolean {\n const { itemSelector, theme } = this.calendar.options.options;\n\n if (!this.root) {\n this.root = select(itemSelector)\n .append('svg')\n .attr('data-theme', theme)\n .attr('class', DEFAULT_SELECTOR.slice(1));\n this.domainsContainerPainter.setup();\n }\n\n this.calendar.pluginManager.setupAll();\n\n return true;\n }\n\n paint(navigationDir: ScrollDirection = ScrollDirection.SCROLL_NONE) {\n const transitions = this.domainsContainerPainter\n .paint(navigationDir)\n .concat(this.pluginPainter.paint())\n .concat(this.domainsContainerPainter.updatePosition());\n\n this.#resize();\n\n return Promise.allSettled(transitions);\n }\n\n #getHeight(): Dimensions['height'] {\n return (\n this.domainsContainerPainter.height() + this.pluginPainter.insideHeight()\n );\n }\n\n #getWidth(): Dimensions['width'] {\n return (\n this.domainsContainerPainter.width() + this.pluginPainter.insideWidth()\n );\n }\n\n #resize(): void {\n const { options } = this.calendar.options;\n\n const newWidth = this.#getWidth();\n const newHeight = this.#getHeight();\n\n this.root\n .transition()\n .duration(options.animationDuration)\n .attr('width', newWidth)\n .attr('height', newHeight);\n\n if (\n newWidth !== this.dimensions.width ||\n newHeight !== this.dimensions.height\n ) {\n this.calendar.eventEmitter.emit(\n 'resize',\n newWidth,\n newHeight,\n this.dimensions.width,\n this.dimensions.height,\n );\n }\n\n this.dimensions = {\n width: newWidth,\n height: newHeight,\n };\n }\n\n destroy(): Promise {\n const result: Promise[] = this.calendar.pluginManager\n .destroyAll()\n .concat(this.domainsContainerPainter.destroy());\n\n if (!this.root) {\n return Promise.allSettled(result);\n }\n\n result.push(\n this.root\n .transition()\n .duration(this.calendar.options.options.animationDuration)\n .attr('width', 0)\n .attr('height', 0)\n .remove()\n .end(),\n );\n\n return Promise.allSettled(result);\n }\n}\n"],"names":["fails","exec","error","descriptors","require$$0","Object","defineProperty","get","functionBindNative","test","bind","hasOwnProperty","NATIVE_BIND","FunctionPrototype","Function","prototype","call","uncurryThisWithBind","functionUncurryThis","fn","apply","arguments","isNullOrUndefined","it","$TypeError","TypeError","requireObjectCoercible","$Object","toObject","argument","require$$1","hasOwnProperty_1","hasOwn","key","DESCRIPTORS","getDescriptor","getOwnPropertyDescriptor","EXISTS","functionName","PROPER","name","CONFIGURABLE","configurable","makeBuiltIn$3","exports","documentAll","document","all","documentAll_1","IS_HTMLDDA","undefined","isCallable","check","Math","global","globalThis","window","self","this","defineGlobalProperty","value","writable","SHARED","sharedStore","store","require$$2","functionToString","toString","inspectSource","match","version","WeakMap","weakMapBasicDetection","String","isObject","objectDefineProperty","createElement","documentCreateElement","ie8DomDefine","a","v8PrototypeDefineBug","$String","anObject","functionCall","getBuiltIn","namespace","method","length","objectIsPrototypeOf","isPrototypeOf","engineUserAgent","navigator","userAgent","process","Deno","versions","v8","split","engineV8Version","V8_VERSION","symbolConstructorDetection","getOwnPropertySymbols","symbol","Symbol","sham","useSymbolAsUid","iterator","isSymbol","require$$3","$Symbol","tryToString","aCallable","getMethod","V","P","func","shared$3","sharedModule","push","mode","copyright","license","source","uncurryThis","id","postfix","random","uid","shared","NATIVE_SYMBOL","require$$4","USE_SYMBOL_AS_UID","require$$5","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","wellKnownSymbol","ordinaryToPrimitive","input","pref","val","valueOf","TO_PRIMITIVE","toPrimitive","result","exoticToPrim","toPropertyKey","IE8_DOM_DEFINE","V8_PROTOTYPE_DEFINE_BUG","$defineProperty","$getOwnPropertyDescriptor","ENUMERABLE","WRITABLE","f","O","Attributes","current","enumerable","set","has","createPropertyDescriptor","bitmap","definePropertyModule","createNonEnumerableProperty","object","keys","sharedKey","hiddenKeys","NATIVE_WEAK_MAP","require$$6","require$$7","OBJECT_ALREADY_INITIALIZED","state","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","CONFIGURABLE_FUNCTION_NAME","enforceInternalState","getInternalState","stringSlice","slice","replace","join","CONFIGURABLE_LENGTH","TEMPLATE","makeBuiltIn","makeBuiltInModule","options","getter","setter","arity","constructor","defineBuiltInAccessor","target","descriptor","FUNCTION_NAME_EXISTS","nameRE","regExpExec","objectGetOwnPropertyDescriptor","objectPropertyIsEnumerable","$propertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","classofRaw","classof","indexedObject","IndexedObject","toIndexedObject","propertyIsEnumerableModule","defineBuiltIn","simple","unsafe","nonConfigurable","nonWritable","ceil","floor","trunc","x","n","toIntegerOrInfinity","number","max","min","toAbsoluteIndex","index","integer","toLength","lengthOfArrayLike","obj","createMethod","IS_INCLUDES","$this","el","fromIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","i","enumBugKeys","internalObjectKeys","concat","objectGetOwnPropertyNames","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","ownKeys","getOwnPropertyDescriptorModule","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","toLowerCase","isForced_1","copyConstructorProperties","exceptions","_export","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","objectKeys","require$$8","$assign","assign","objectAssign","b","A","B","alphabet","forEach","chr","T","argumentsLength","S","j","toStringTagSupport","TO_STRING_TAG_SUPPORT","TO_STRING_TAG","CORRECT_ARGUMENTS","tag","tryGet","callee","engineIsNode","uncurryThisAccessor","aPossiblePrototype","objectSetPrototypeOf","setPrototypeOf","CORRECT_SETTER","Array","proto","__proto__","setToStringTag","TAG","SPECIES","setSpecies","CONSTRUCTOR_NAME","Constructor","anInstance","Prototype","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","$location","defer","channel","port","isConstructor","called","aConstructor","functionApply","Reflect","functionUncurryThisClause","functionBindContext","that","html","arraySlice","engineIsIos","validateArgumentsLength","passed","required","IS_IOS","require$$10","IS_NODE","require$$11","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","location","run","runner","eventListener","event","globalPostMessageDefer","postMessage","protocol","host","handler","args","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","task","Queue","head","tail","add","item","entry","next","notify","toggle","node","promise","then","engineIsIosPebble","Pebble","engineIsWebosWebkit","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","Promise","queueMicrotaskDescriptor","microtask","flush","parent","domain","exit","enter","resolve","createTextNode","observe","characterData","microtask_1","perform","promiseNativeConstructor","engineIsDeno","engineIsBrowser","NativePromiseConstructor","IS_BROWSER","IS_DENO","require$$9","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","promiseConstructorDetection","CONSTRUCTOR","REJECTION_EVENT","newPromiseCapability$2","PromiseCapability","C","reject","$$resolve","$$reject","newPromiseCapability","Internal","OwnPromiseCapability","nativeThen","$","require$$12","speciesConstructor","defaultConstructor","require$$14","require$$15","hostReportErrors","console","require$$17","require$$18","InternalStateModule","require$$19","require$$20","newPromiseCapabilityModule","require$$22","PROMISE","require$$21","NATIVE_PROMISE_SUBCLASSING","getInternalPromiseState","setInternalState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","isThenable","callReaction","reaction","exited","ok","fail","rejection","onHandleUnhandled","isReject","notified","reactions","onUnhandled","reason","initEvent","isUnhandled","emit","unwrap","internalReject","done","internalResolve","wrapper","executor","onFulfilled","onRejected","PromiseWrapper","wrap","iterators","Iterators","ITERATOR","ArrayPrototype","isArrayIteratorMethod","getIteratorMethod","getIterator","usingIterator","iteratorMethod","iteratorClose","kind","innerResult","innerError","Result","stopped","ResultPrototype","iterate","iterable","unboundFunction","iterFn","step","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","SAFE_CLOSING","iteratorWithReturn","return","from","checkCorrectnessOfIteration","SKIP_CLOSING","ITERATION_SUPPORT","promiseStaticsIncorrectIteration","capability","$promiseResolve","values","remaining","alreadyCalled","real","catch","race","r","promiseResolve","promiseCapability","objectDefineProperties","defineProperties","Properties","props","activeXDocument","definePropertiesModule","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","style","display","src","contentWindow","open","F","objectCreate","create","UNSCOPABLES","IteratorPrototype","PrototypeOfArrayIteratorPrototype","arrayIterator","addToUnscopables","correctPrototypeGetter","getPrototypeOf","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","objectGetPrototypeOf","BUGGY_SAFARI_ITERATORS","NEW_ITERATOR_PROTOTYPE","iteratorsCore","returnThis","createIteratorConstructor","IteratorConstructor","NAME","ENUMERABLE_NEXT","PROPER_FUNCTION_NAME","require$$13","KEYS","VALUES","ENTRIES","iteratorDefine","Iterable","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","createIterResultObject","defineIterator","ARRAY_ITERATOR","es_array_iterator","iterated","Arguments","charAt","charCodeAt","CONVERT_TO_STRING","pos","first","second","position","size","codeAt","STRING_ITERATOR","point","internalMetadata","objectGetOwnPropertyNamesExternal","createProperty","propertyKey","$Array","arraySliceSimple","start","end","k","fin","$getOwnPropertyNames","windowNames","getWindowNames","arrayBufferNonExtensible","ArrayBuffer","buffer","isExtensible","ARRAY_BUFFER_NON_EXTENSIBLE","$isExtensible","objectIsExtensible","freezing","preventExtensions","getOwnPropertyNamesExternalModule","FREEZING","REQUIRED","METADATA","setMetadata","objectID","weakData","meta","internalMetadataModule","enable","splice","fastKey","getWeakData","onFreeze","InternalMetadataModule","inheritIfRequired","dummy","Wrapper","NewTarget","NewTargetPrototype","collection","common","IS_MAP","IS_WEAK","ADDER","NativeConstructor","NativePrototype","exported","fixMethod","uncurriedNativeMethod","getConstructor","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","setStrong","defineBuiltIns","isArray","arraySpeciesConstructor","originalArray","arraySpeciesCreate","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_REJECT","NO_HOLES","callbackfn","specificCreate","boundFunction","arrayIteration","map","filter","some","every","find","findIndex","filterReject","internalStateGetterFor","uncaughtFrozenStore","frozen","UncaughtFrozenStore","findUncaughtFrozen","delete","collectionWeak","define","init","domIterables","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DOMTokenList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","classList","DOMTokenListPrototype","domTokenListPrototype","DOMIterables","ArrayIteratorMethods","ArrayValues","handlePrototype","CollectionPrototype","COLLECTION_NAME","METHOD_NAME","arrayMethodHasSpeciesSupport","array","foo","Boolean","nativeSlice","HAS_SPECIES_SUPPORT","arrayMethodIsStrict","nativeJoin","__classPrivateFieldGet","receiver","separator","nativeKeys","MATCH","isRegExp","notARegExp","correctIsRegExpLogic","regexp","error1","error2","nativeStartsWith","startsWith","CORRECT_IS_REGEXP_LOGIC","searchString","search","$forEach","IE_BUG","TO_ENTRIES","IE_WORKAROUND","$entries","defined","Number","isNaN","ascendingDefined","ascending","finite","isFinite","NaN","positive","negative","re","parse","fallback","Date","timeIntervals","Map","timeSecond","timeMinute","timeHour","timeDay","timeWeek","timeMonth","timeYear","timeMonday","timeTuesday","timeWednesday","timeThursday","timeFriday","timeSaturday","timeSunday","utcIntervals","utcSecond","utcMinute","utcHour","utcDay","utcWeek","utcMonth","utcYear","utcMonday","utcTuesday","utcWednesday","utcThursday","utcFriday","utcSaturday","utcSunday","maybeTimeInterval","interval","Error","maybeUtcInterval","TypedArray","Uint8Array","objectToString","constant","coerceNumbers","coerceNumber","Float64Array","coerceDates","coerceDate","isoParse","arrayify","isScaleOptions","option","maybeInterval","isInteger","abs","d","offset","range","lo","hi","rangei","maybeRangeInterval","isOrdinal","isTemporal","isTemporalString","isNumericString","trim","orderof","last","descending","color","radius","opacity","registry","sqrt4_3","sqrt","symbols","symbolAsterisk","symbolCircle","symbolCross","symbolDiamond","symbolDiamond2","draw","context","rx","PI","ry","hy","moveTo","lineTo","closePath","symbolPlus","symbolSquare","symbolSquare2","symbolStar","symbolTimes","symbolTriangle","symbolTriangle2","symbolWye","maybeSymbol","isSymbolObject","warn","message","ordinalSchemes","schemeAccent","schemeCategory10","schemeDark2","schemePaired","schemePastel1","schemePastel2","schemeSet1","schemeSet2","schemeSet3","schemeTableau10","scheme11","schemeBrBG","interpolateBrBG","schemePRGn","interpolatePRGn","schemePiYG","interpolatePiYG","schemePuOr","interpolatePuOr","schemeRdBu","interpolateRdBu","schemeRdGy","interpolateRdGy","schemeRdYlBu","interpolateRdYlBu","schemeRdYlGn","interpolateRdYlGn","schemeSpectral","interpolateSpectral","scheme11r","scheme9","schemeBlues","interpolateBlues","schemeGreens","interpolateGreens","schemeGreys","interpolateGreys","schemeOranges","interpolateOranges","schemePurples","interpolatePurples","schemeReds","interpolateReds","schemei","interpolateTurbo","interpolateViridis","interpolateMagma","interpolateInferno","interpolatePlasma","interpolateCividis","interpolateCubehelixDefault","interpolateWarm","interpolateCool","schemeBuGn","interpolateBuGn","schemeBuPu","interpolateBuPu","schemeGnBu","interpolateGnBu","schemeOrRd","interpolateOrRd","schemePuBu","interpolatePuBu","schemePuBuGn","interpolatePuBuGn","schemePuRd","interpolatePuRd","schemeRdPu","interpolateRdPu","schemeYlGn","interpolateYlGn","schemeYlGnBu","interpolateYlGnBu","schemeYlOrBr","interpolateYlOrBr","schemeYlOrRd","interpolateYlOrRd","schemeicyclical","interpolateRainbow","interpolateSinebow","scheme","interpolate","quantize","t","reverse","ordinalScheme","s","ordinalRange","quantitativeSchemes","quantitativeScheme","divergingSchemes","Set","isDivergingScheme","flip","unit","interpolators","interpolateNumber","interpolateRgb","interpolateHsl","interpolateHcl","interpolateLab","maybeInterpolator","createScaleQ","scale","channels","nice","clamp","zero","inferAutoDomain","unknown","round","inferRadialRange","inferLengthRange","interpolateRound","_","interpolatePiecewise","extent","sign","reverseof","maybeNiceInterval","maybeNice","createScalePow","exponent","scalePow","createScaleThreshold","isOrdered","scaleThreshold","inferDomain","inferZeroDomain","hint","h25","quantile","h50","median","inferLogDomain","v","inferQuantileDomain","createScaleD","transform","pivot","symmetric","piecewise","mid","mindelta","maxdelta","invert","interpolator","createScaleDivergingPow","scaleDivergingPow","transformSqrt","pow","transformPow","createScaleDivergingSymlog","scaleDivergingSymlog","log1p","expm1","transformSymlog","transformIdentity","transformLog","log","exp","createScaleT","ordinalImplicit","createScaleO","createScaleOrdinal","fill","inferHint","stroke","inferSymbolHint","isNone","symbolsStroke","symbolsFill","inferSymbolRange","maybeBooleanRange","t0","scaleImplicit","scaleOrdinal","maybeRound","InternSet","sort","candidate","normalizeScale","projection","typeProjection","asOrdinalType","inferScaleType","isOrdinalScale","formatScaleType","coerceType","coerceSymbols","scaleDiverging","createScaleDiverging","createScaleDivergingSqrt","base","scaleDivergingLog","createScaleDivergingLog","scaleLinear","createScaleLinear","createScaleSqrt","quantiles","scaleQuantile","createScaleQuantile","thresholds","ticks","pop","createScaleQuantize","scaleLog","createScaleLog","scaleSymlog","createScaleSymlog","scaleUtc","createScaleUtc","scaleTime","createScaleTime","align","padding","scalePoint","createScalePoint","paddingInner","paddingOuter","scaleBand","createScaleBand","scaleIdentity","createScale","description","coerceValues","c","exposeScale","percent","bandwidth","ScrollDirection","Position","SCALE_BASE_OPACITY_COLOR","normalizedScale","scaleOptions","scaleType","applyScaleStyle","elem","_scale","keyname","styles","baseColor","scaleStyle","_ref","_ref2","_slicedToArray","prop","doesNotExceedSafeInteger","IS_CONCAT_SPREADABLE","IS_CONCAT_SPREADABLE_SUPPORT","isConcatSpreadable","spreadable","arg","len","E","allSettled","status","collectionStrong","previous","getEntry","removed","prev","ITERATOR_NAME","getInternalCollectionState","getInternalIteratorState","mergeSort","comparefn","middle","insertionSort","merge","element","left","right","llength","rlength","lindex","rindex","arraySort","firefox","engineFfVersion","engineIsIeOrEdge","webkit","engineWebkitVersion","deletePropertyOrThrow","internalSort","FF","IE_OR_EDGE","V8","WEBKIT","nativeSort","FAILS_ON_UNDEFINED","FAILS_ON_NULL","STRICT_METHOD","STABLE_SORT","code","fromCharCode","itemsLength","items","arrayLength","y","getSortCompare","$includes","$map","$filter","callWithSafeIterationClosing","arrayLike","IS_CONSTRUCTOR","mapfn","mapping","whitespaces","ltrim","RegExp","rtrim","stringTrim","$trim","forcedStringTrimMethod","DEFAULT_SELECTOR","defaultOptions","enabled","itemSelector","width","height","gutter","includeBlank","LegendLite","calendar","_classCallCheck","root","shown","pluginOptions","_this$options","select","destroy","append","attr","selectAll","remove","_this$options2","localRange","_toConsumableArray","unshift","sc","_this","_LegendLite_instances","_LegendLite_nodeAttrs","update","selection","_this2","_this$options3","_d"],"mappings":"y7JACAA,GAAiB,SAAUC,GACzB,IACE,QAASA,GACV,CAAC,MAAOC,GACP,OAAO,CACR,CACH,ECHAC,IAHYC,IAGY,WAEtB,OAA+E,IAAxEC,OAAOC,eAAe,GAAI,EAAG,CAAEC,IAAK,WAAc,OAAO,CAAI,IAAI,EAC1E,ICJAC,IAFYJ,IAEY,WAEtB,IAAIK,EAAO,WAA4B,EAAEC,OAEzC,MAAsB,mBAARD,GAAsBA,EAAKE,eAAe,YAC1D,ICPIC,GAAcR,GAEdS,GAAoBC,SAASC,UAC7BC,GAAOH,GAAkBG,KACzBC,GAAsBL,IAAeC,GAAkBH,KAAKA,KAAKM,GAAMA,IAE3EE,GAAiBN,GAAcK,GAAsB,SAAUE,GAC7D,OAAO,WACL,OAAOH,GAAKI,MAAMD,EAAIE,UAC1B,CACA,ECRAC,GAAiB,SAAUC,GACzB,OAAOA,OACT,ECJID,GAAoBlB,GAEpBoB,GAAaC,UAIjBC,GAAiB,SAAUH,GACzB,GAAID,GAAkBC,GAAK,MAAM,IAAIC,GAAW,wBAA0BD,GAC1E,OAAOA,CACT,ECTIG,GAAyBtB,GAEzBuB,GAAUtB,OAIduB,GAAiB,SAAUC,GACzB,OAAOF,GAAQD,GAAuBG,GACxC,ECPID,GAAWE,GAEXnB,GAHcP,GAGe,GAAGO,gBAKpCoB,GAAiB1B,OAAO2B,QAAU,SAAgBT,EAAIU,GACpD,OAAOtB,GAAeiB,GAASL,GAAKU,EACtC,ECVIC,GAAc9B,GACd4B,GAASF,GAETjB,GAAoBC,SAASC,UAE7BoB,GAAgBD,IAAe7B,OAAO+B,yBAEtCC,GAASL,GAAOnB,GAAmB,QAKvCyB,GAAiB,CACfD,OAAQA,GACRE,OALWF,IAA0D,cAAhD,WAAqC,EAAEG,KAM5DC,aALiBJ,MAAYH,IAAgBA,IAAeC,GAActB,GAAmB,QAAQ6B,eCVvGC,GAAA,CAAAC,QAAA,CAAA,GAAIC,GAAiC,iBAAZC,UAAwBA,SAASC,IAM1DC,GAAiB,CACfD,IAAKF,GACLI,gBAJqC,IAAfJ,SAA8CK,IAAhBL,ICFlDA,GAFezC,GAEY2C,IAI/BI,GANmB/C,GAMW6C,WAAa,SAAUpB,GACnD,MAA0B,mBAAZA,GAA0BA,IAAagB,EACvD,EAAI,SAAUhB,GACZ,MAA0B,mBAAZA,CAChB,ECVIuB,GAAQ,SAAU7B,GACpB,OAAOA,GAAMA,EAAG8B,OAASA,MAAQ9B,CACnC,EAGA+B,GAEEF,GAA2B,iBAAdG,YAA0BA,aACvCH,GAAuB,iBAAVI,QAAsBA,SAEnCJ,GAAqB,iBAARK,MAAoBA,OACjCL,GAAuB,iBAAVE,IAAsBA,KACnCF,GAAqB,iBAARM,IAAoBA,KAEjC,WAAe,OAAOA,IAAO,CAA7B,IAAoC5C,SAAS,cAATA,GCdlCwC,GAASlD,GAGTE,GAAiBD,OAAOC,eAE5BqD,GAAiB,SAAU1B,EAAK2B,GAC9B,IACEtD,GAAegD,GAAQrB,EAAK,CAAE2B,MAAOA,EAAOlB,cAAc,EAAMmB,UAAU,GAC3E,CAAC,MAAO3D,GACPoD,GAAOrB,GAAO2B,CACf,CAAC,OAAOA,CACX,ECVID,GAAuB7B,GAEvBgC,GAAS,qBAGbC,GANa3D,GAIM0D,KAAWH,GAAqBG,GAAQ,CAAA,GCHvDX,GAAarB,GACbkC,GAAQC,GAERC,GAJc9D,GAIiBU,SAASqD,UAGvChB,GAAWa,GAAMI,iBACpBJ,GAAMI,cAAgB,SAAU7C,GAC9B,OAAO2C,GAAiB3C,EAC5B,OCHI8C,GAAOC,GDMXF,GAAiBJ,GAAMI,cEZnBjB,GAAarB,GAEbyC,GAHSnE,GAGQmE,QAErBC,GAAiBrB,GAAWoB,KAAY,cAAc9D,KAAKgE,OAAOF,KCL9DpB,GAAa/C,GAGbyC,GAFef,GAEYiB,IAE/B2B,GAJmB5C,GAIWmB,WAAa,SAAU1B,GACnD,MAAoB,iBAANA,EAAwB,OAAPA,EAAc4B,GAAW5B,IAAOA,IAAOsB,EACxE,EAAI,SAAUtB,GACZ,MAAoB,iBAANA,EAAwB,OAAPA,EAAc4B,GAAW5B,EAC1D,ECTAoD,GAAA,CAAA,EACID,GAAW5C,GAEXgB,GAHS1C,GAGS0C,SAElBT,GAASqC,GAAS5B,KAAa4B,GAAS5B,GAAS8B,eAErDC,GAAiB,SAAUtD,GACzB,OAAOc,GAASS,GAAS8B,cAAcrD,GAAM,CAAA,CAC/C,ECPIqD,GAAgBX,GAGpBa,IALkB1E,KACN0B,IAI4B,WAEtC,OAES,IAFFzB,OAAOC,eAAesE,GAAc,OAAQ,IAAK,CACtDrE,IAAK,WAAc,OAAO,CAAI,IAC7BwE,CACL,ICLAC,GALkB5E,IACN0B,IAI0B,WAEpC,OAGiB,KAHVzB,OAAOC,gBAAe,WAAY,GAAiB,YAAa,CACrEsD,MAAO,GACPC,UAAU,IACT9C,SACL,ICXI2D,GAAWtE,GAEX6E,GAAUR,OACVjD,GAAaC,UAGjByD,GAAiB,SAAUrD,GACzB,GAAI6C,GAAS7C,GAAW,OAAOA,EAC/B,MAAM,IAAIL,GAAWyD,GAAQpD,GAAY,oBAC3C,ECTIjB,GAAcR,GAEdY,GAAOF,SAASC,UAAUC,KAE9BmE,GAAiBvE,GAAcI,GAAKN,KAAKM,IAAQ,WAC/C,OAAOA,GAAKI,MAAMJ,GAAMK,UAC1B,ECNIiC,GAASlD,GACT+C,GAAarB,GAMjBsD,GAAiB,SAAUC,EAAWC,GACpC,OAAOjE,UAAUkE,OAAS,GALF1D,EAKgByB,GAAO+B,GAJxClC,GAAWtB,GAAYA,OAAWqB,GAIoBI,GAAO+B,IAAc/B,GAAO+B,GAAWC,GALtF,IAAUzD,CAM1B,ECPA2D,GAFkBpF,GAEW,CAAE,EAACqF,eCFhCC,GAAqC,oBAAbC,WAA4BlB,OAAOkB,UAAUC,YAAc,GVA/EtC,GAASlD,GACTwF,GAAY9D,GAEZ+D,GAAUvC,GAAOuC,QACjBC,GAAOxC,GAAOwC,KACdC,GAAWF,IAAWA,GAAQE,UAAYD,IAAQA,GAAKxB,QACvD0B,GAAKD,IAAYA,GAASC,GAG1BA,KAIF1B,IAHAD,GAAQ2B,GAAGC,MAAM,MAGD,GAAK,GAAK5B,GAAM,GAAK,EAAI,IAAMA,GAAM,GAAKA,GAAM,MAK7DC,IAAWsB,OACdvB,GAAQuB,GAAUvB,MAAM,iBACVA,GAAM,IAAM,MACxBA,GAAQuB,GAAUvB,MAAM,oBACbC,IAAWD,GAAM,IAIhC,IAAA6B,GAAiB5B,GWzBb6B,GAAa/F,GACbJ,GAAQ8B,GAGRmD,GAFShB,GAEQQ,OAGrB2B,KAAmB/F,OAAOgG,wBAA0BrG,IAAM,WACxD,IAAIsG,EAASC,OAAO,oBAKpB,OAAQtB,GAAQqB,MAAajG,OAAOiG,aAAmBC,UAEpDA,OAAOC,MAAQL,IAAcA,GAAa,EAC/C,ICdAM,GAFoBrG,KAGdmG,OAAOC,MACkB,iBAAnBD,OAAOG,SCLftB,GAAahF,GACb+C,GAAarB,GACb2D,GAAgBxB,GAGhBtC,GAAUtB,OAEdsG,GAJwBC,GAIa,SAAUrF,GAC7C,MAAoB,iBAANA,CAChB,EAAI,SAAUA,GACZ,IAAIsF,EAAUzB,GAAW,UACzB,OAAOjC,GAAW0D,IAAYpB,GAAcoB,EAAQ9F,UAAWY,GAAQJ,GACzE,ECZI0D,GAAUR,OAEdqC,GAAiB,SAAUjF,GACzB,IACE,OAAOoD,GAAQpD,EAChB,CAAC,MAAO3B,GACP,MAAO,QACR,CACH,ECRIiD,GAAa/C,GACb0G,GAAchF,GAEdN,GAAaC,UAGjBsF,GAAiB,SAAUlF,GACzB,GAAIsB,GAAWtB,GAAW,OAAOA,EACjC,MAAM,IAAIL,GAAWsF,GAAYjF,GAAY,qBAC/C,ECTIkF,GAAY3G,GACZkB,GAAoBQ,GAIxBkF,GAAiB,SAAUC,EAAGC,GAC5B,IAAIC,EAAOF,EAAEC,GACb,OAAO5F,GAAkB6F,QAAQjE,EAAY6D,GAAUI,EACzD,ECRInG,GAAOZ,GACP+C,GAAarB,GACb4C,GAAWT,GAEXzC,GAAaC,UCHjB2F,GAAA,CAAAxE,QAAA,CAAA,GAAIoB,GAAQlC,IAEXuF,WAAiB,SAAUpF,EAAK2B,GAC/B,OAAOI,GAAM/B,KAAS+B,GAAM/B,QAAiBiB,IAAVU,EAAsBA,EAAQ,CAAA,EACnE,GAAG,WAAY,IAAI0D,KAAK,CACtBhD,QAAS,SACTiD,KAAyB,SACzBC,UAAW,4CACXC,QAAS,2DACTC,OAAQ,0DCVNC,GAAcvH,GAEdwH,GAAK,EACLC,GAAUxE,KAAKyE,SACf3D,GAAWwD,GAAY,GAAIxD,UAE/B4D,GAAiB,SAAU9F,GACzB,MAAO,gBAAqBiB,IAARjB,EAAoB,GAAKA,GAAO,KAAOkC,KAAWyD,GAAKC,GAAS,GACtF,ECPIG,GAASlG,GACTE,GAASiC,GACT8D,GAAMnB,GACNqB,GAAgBC,GAChBC,GAAoBC,GAEpB7B,GAPSnG,GAOOmG,OAChB8B,GAAwBL,GAAO,OAC/BM,GAAwBH,GAAoB5B,GAAY,KAAKA,GAASA,IAAUA,GAAOgC,eAAiBR,GAE5GS,GAAiB,SAAUhG,GAKvB,OAJGR,GAAOqG,GAAuB7F,KACjC6F,GAAsB7F,GAAQyF,IAAiBjG,GAAOuE,GAAQ/D,GAC1D+D,GAAO/D,GACP8F,GAAsB,UAAY9F,IAC/B6F,GAAsB7F,EACjC,ECjBIxB,GAAOZ,GACPsE,GAAW5C,GACX6E,GAAW1C,GACX+C,GAAYJ,GACZ6B,GJIa,SAAUC,EAAOC,GAChC,IAAIxH,EAAIyH,EACR,GAAa,WAATD,GAAqBxF,GAAWhC,EAAKuH,EAAMvE,YAAcO,GAASkE,EAAM5H,GAAKG,EAAIuH,IAAS,OAAOE,EACrG,GAAIzF,GAAWhC,EAAKuH,EAAMG,WAAanE,GAASkE,EAAM5H,GAAKG,EAAIuH,IAAS,OAAOE,EAC/E,GAAa,WAATD,GAAqBxF,GAAWhC,EAAKuH,EAAMvE,YAAcO,GAASkE,EAAM5H,GAAKG,EAAIuH,IAAS,OAAOE,EACrG,MAAM,IAAIpH,GAAW,0CACvB,EIPIA,GAAaC,UACbqH,GAHkBV,GAGa,eCR/BW,GDYa,SAAUL,EAAOC,GAChC,IAAKjE,GAASgE,IAAU/B,GAAS+B,GAAQ,OAAOA,EAChD,IACIM,EADAC,EAAejC,GAAU0B,EAAOI,IAEpC,GAAIG,EAAc,CAGhB,QAFa/F,IAATyF,IAAoBA,EAAO,WAC/BK,EAAShI,GAAKiI,EAAcP,EAAOC,IAC9BjE,GAASsE,IAAWrC,GAASqC,GAAS,OAAOA,EAClD,MAAM,IAAIxH,GAAW,0CACtB,CAED,YADa0B,IAATyF,IAAoBA,EAAO,UACxBF,GAAoBC,EAAOC,EACpC,ECvBIhC,GAAW7E,GAIfoH,GAAiB,SAAUrH,GACzB,IAAII,EAAM8G,GAAYlH,EAAU,UAChC,OAAO8E,GAAS1E,GAAOA,EAAMA,EAAM,EACrC,ECRIC,GAAc9B,GACd+I,GAAiBrH,GACjBsH,GAA0BnF,GAC1BiB,GAAW0B,GACXsC,GAAgBhB,GAEhB1G,GAAaC,UAEb4H,GAAkBhJ,OAAOC,eAEzBgJ,GAA4BjJ,OAAO+B,yBACnCmH,GAAa,aACb9G,GAAe,eACf+G,GAAW,WAIf7E,GAAA8E,EAAYvH,GAAckH,GAA0B,SAAwBM,EAAGxC,EAAGyC,GAIhF,GAHAzE,GAASwE,GACTxC,EAAIgC,GAAchC,GAClBhC,GAASyE,GACQ,mBAAND,GAA0B,cAANxC,GAAqB,UAAWyC,GAAcH,MAAYG,IAAeA,EAAWH,IAAW,CAC5H,IAAII,EAAUN,GAA0BI,EAAGxC,GACvC0C,GAAWA,EAAQJ,MACrBE,EAAExC,GAAKyC,EAAW/F,MAClB+F,EAAa,CACXjH,aAAcD,MAAgBkH,EAAaA,EAAWlH,IAAgBmH,EAAQnH,IAC9EoH,WAAYN,MAAcI,EAAaA,EAAWJ,IAAcK,EAAQL,IACxE1F,UAAU,GAGf,CAAC,OAAOwF,GAAgBK,EAAGxC,EAAGyC,EACjC,EAAIN,GAAkB,SAAwBK,EAAGxC,EAAGyC,GAIlD,GAHAzE,GAASwE,GACTxC,EAAIgC,GAAchC,GAClBhC,GAASyE,GACLR,GAAgB,IAClB,OAAOE,GAAgBK,EAAGxC,EAAGyC,EACjC,CAAI,MAAOzJ,GAAsB,CAC/B,GAAI,QAASyJ,GAAc,QAASA,EAAY,MAAM,IAAInI,GAAW,2BAErE,MADI,UAAWmI,IAAYD,EAAExC,GAAKyC,EAAW/F,OACtC8F,CACT,EC1CA,ICYII,GAAKvJ,GAAKwJ,GDZdC,GAAiB,SAAUC,EAAQrG,GACjC,MAAO,CACLiG,aAAuB,EAATI,GACdvH,eAAyB,EAATuH,GAChBpG,WAAqB,EAAToG,GACZrG,MAAOA,EAEX,EENIsG,GAAuBpI,GACvBkI,GAA2B/F,GAE/BkG,GAJkB/J,GAIa,SAAUgK,EAAQnI,EAAK2B,GACpD,OAAOsG,GAAqBT,EAAEW,EAAQnI,EAAK+H,GAAyB,EAAGpG,GACzE,EAAI,SAAUwG,EAAQnI,EAAK2B,GAEzB,OADAwG,EAAOnI,GAAO2B,EACPwG,CACT,ECRIrC,GAAMjG,GAENuI,GAHSjK,GAGK,QAElBkK,GAAiB,SAAUrI,GACzB,OAAOoI,GAAKpI,KAASoI,GAAKpI,GAAO8F,GAAI9F,GACvC,ECPAsI,GAAiB,CAAA,EHAbC,GAAkBpK,GAClBkD,GAASxB,GACT4C,GAAWT,GACXkG,GAA8BvD,GAC9B5E,GAASkG,GACTF,GAASI,GACTkC,GAAYG,GACZF,GAAaG,GAEbC,GAA6B,6BAC7BlJ,GAAY6B,GAAO7B,UACnB8C,GAAUjB,GAAOiB,QAgBrB,GAAIiG,IAAmBxC,GAAO4C,MAAO,CACnC,IAAI5G,GAAQgE,GAAO4C,QAAU5C,GAAO4C,MAAQ,IAAIrG,IAEhDP,GAAMzD,IAAMyD,GAAMzD,IAClByD,GAAM+F,IAAM/F,GAAM+F,IAClB/F,GAAM8F,IAAM9F,GAAM8F,IAElBA,GAAM,SAAUvI,EAAIsJ,GAClB,GAAI7G,GAAM+F,IAAIxI,GAAK,MAAM,IAAIE,GAAUkJ,IAGvC,OAFAE,EAASC,OAASvJ,EAClByC,GAAM8F,IAAIvI,EAAIsJ,GACPA,CACX,EACEtK,GAAM,SAAUgB,GACd,OAAOyC,GAAMzD,IAAIgB,IAAO,CAAA,CAC5B,EACEwI,GAAM,SAAUxI,GACd,OAAOyC,GAAM+F,IAAIxI,EACrB,CACA,KAAO,CACL,IAAIwJ,GAAQT,GAAU,SACtBC,GAAWQ,KAAS,EACpBjB,GAAM,SAAUvI,EAAIsJ,GAClB,GAAI7I,GAAOT,EAAIwJ,IAAQ,MAAM,IAAItJ,GAAUkJ,IAG3C,OAFAE,EAASC,OAASvJ,EAClB4I,GAA4B5I,EAAIwJ,GAAOF,GAChCA,CACX,EACEtK,GAAM,SAAUgB,GACd,OAAOS,GAAOT,EAAIwJ,IAASxJ,EAAGwJ,IAAS,EAC3C,EACEhB,GAAM,SAAUxI,GACd,OAAOS,GAAOT,EAAIwJ,GACtB,CACA,CAEA,IAAAC,GAAiB,CACflB,IAAKA,GACLvJ,IAAKA,GACLwJ,IAAKA,GACLkB,QArDY,SAAU1J,GACtB,OAAOwI,GAAIxI,GAAMhB,GAAIgB,GAAMuI,GAAIvI,EAAI,CAAA,EACrC,EAoDE2J,UAlDc,SAAUC,GACxB,OAAO,SAAU5J,GACf,IAAIqJ,EACJ,IAAKlG,GAASnD,KAAQqJ,EAAQrK,GAAIgB,IAAK6J,OAASD,EAC9C,MAAM,IAAI1J,GAAU,0BAA4B0J,EAAO,aACvD,OAAOP,CACb,CACA,GIzBIjD,GAAcvH,GACdJ,GAAQ8B,GACRqB,GAAac,GACbjC,GAAS4E,GACT1E,GAAcgG,GACdmD,GAA6BjD,GAAsC3F,aACnE2B,GAAgBqG,GAGhBa,GAFsBZ,GAEqBO,QAC3CM,GAHsBb,GAGiBnK,IACvC0E,GAAUR,OAEVnE,GAAiBD,OAAOC,eACxBkL,GAAc7D,GAAY,GAAG8D,OAC7BC,GAAU/D,GAAY,GAAG+D,SACzBC,GAAOhE,GAAY,GAAGgE,MAEtBC,GAAsB1J,KAAgBlC,IAAM,WAC9C,OAAsF,IAA/EM,IAAe,WAA2B,GAAE,SAAU,CAAEsD,MAAO,IAAK2B,MAC7E,IAEIsG,GAAWpH,OAAOA,QAAQwB,MAAM,UAEhC6F,GAAcC,GAAAnJ,QAAiB,SAAUgB,EAAOpB,EAAMwJ,GACf,YAArCR,GAAYvG,GAAQzC,GAAO,EAAG,KAChCA,EAAO,IAAMkJ,GAAQzG,GAAQzC,GAAO,qBAAsB,MAAQ,KAEhEwJ,GAAWA,EAAQC,SAAQzJ,EAAO,OAASA,GAC3CwJ,GAAWA,EAAQE,SAAQ1J,EAAO,OAASA,KAC1CR,GAAO4B,EAAO,SAAYyH,IAA8BzH,EAAMpB,OAASA,KACtEN,GAAa5B,GAAesD,EAAO,OAAQ,CAAEA,MAAOpB,EAAME,cAAc,IACvEkB,EAAMpB,KAAOA,GAEhBoJ,IAAuBI,GAAWhK,GAAOgK,EAAS,UAAYpI,EAAM2B,SAAWyG,EAAQG,OACzF7L,GAAesD,EAAO,SAAU,CAAEA,MAAOoI,EAAQG,QAEnD,IACMH,GAAWhK,GAAOgK,EAAS,gBAAkBA,EAAQI,YACnDlK,IAAa5B,GAAesD,EAAO,YAAa,CAAEC,UAAU,IAEvDD,EAAM7C,YAAW6C,EAAM7C,eAAYmC,EAClD,CAAI,MAAOhD,GAAsB,CAC/B,IAAI0K,EAAQU,GAAqB1H,GAG/B,OAFG5B,GAAO4I,EAAO,YACjBA,EAAMlD,OAASiE,GAAKE,GAAyB,iBAARrJ,EAAmBA,EAAO,KACxDoB,CACX,EAIA9C,SAASC,UAAUoD,SAAW2H,IAAY,WACxC,OAAO3I,GAAWO,OAAS6H,GAAiB7H,MAAMgE,QAAUtD,GAAcV,KAC5E,GAAG,8BCrDCoI,GAAc1L,GACdE,GAAiBwB,GAErBuK,GAAiB,SAAUC,EAAQ9J,EAAM+J,GAGvC,OAFIA,EAAWhM,KAAKuL,GAAYS,EAAWhM,IAAKiC,EAAM,CAAEyJ,QAAQ,IAC5DM,EAAWzC,KAAKgC,GAAYS,EAAWzC,IAAKtH,EAAM,CAAE0J,QAAQ,IACzD5L,GAAemJ,EAAE6C,EAAQ9J,EAAM+J,EACxC,ECPIrK,GAAc9B,GACdoM,GAAuB1K,GAAsCO,OAC7DsF,GAAc1D,GACdoI,GAAwBzF,GAExB/F,GAAoBC,SAASC,UAC7BmD,GAAmByD,GAAY9G,GAAkBsD,UACjDsI,GAAS,mEACTC,GAAa/E,GAAY8E,GAAOxM,MAKhCiC,KAAgBsK,IAClBH,GAAsBxL,GALb,OAKsC,CAC7C6B,cAAc,EACdnC,IAAK,WACH,IACE,OAAOmM,GAAWD,GAAQvI,GAAiBR,OAAO,EACnD,CAAC,MAAOxD,GACP,MAAO,EACR,CACF,IAEL,IAAAyM,GAAA,CAAA,EAAAC,GAAA,CAAA,ECxBIC,GAAwB,CAAE,EAACC,qBAE3B1K,GAA2B/B,OAAO+B,yBAGlC2K,GAAc3K,KAA6ByK,GAAsB7L,KAAK,CAAE,EAAG,GAAK,GAIpF4L,GAAAnD,EAAYsD,GAAc,SAA8B9F,GACtD,IAAIsF,EAAanK,GAAyBsB,KAAMuD,GAChD,QAASsF,GAAcA,EAAW1C,UACpC,EAAIgD,GCZJ,IAAIlF,GAAcvH,GAEd+D,GAAWwD,GAAY,GAAGxD,UAC1BqH,GAAc7D,GAAY,GAAG8D,OAEjCuB,GAAiB,SAAUzL,GACzB,OAAOiK,GAAYrH,GAAS5C,GAAK,GAAI,EACvC,ECNIvB,GAAQ8B,GACRmL,GAAUhJ,GAEVtC,GAAUtB,OACV4F,GALc7F,GAKM,GAAG6F,OAG3BiH,GAAiBlN,IAAM,WAGrB,OAAQ2B,GAAQ,KAAKmL,qBAAqB,EAC5C,IAAK,SAAUvL,GACb,MAAuB,WAAhB0L,GAAQ1L,GAAmB0E,GAAM1E,EAAI,IAAMI,GAAQJ,EAC5D,EAAII,GCbAwL,GAAgB/M,GAChBsB,GAAyBI,GAE7BsL,GAAiB,SAAU7L,GACzB,OAAO4L,GAAczL,GAAuBH,GAC9C,ECNIW,GAAc9B,GACdY,GAAOc,GACPuL,GAA6BpJ,GAC7B+F,GAA2BpD,GAC3BwG,GAAkBlF,GAClBgB,GAAgBd,GAChBpG,GAASyI,GACTtB,GAAiBuB,GAGjBpB,GAA4BjJ,OAAO+B,yBAI9BuK,GAAAlD,EAAGvH,GAAcoH,GAA4B,SAAkCI,EAAGxC,GAGzF,GAFAwC,EAAI0D,GAAgB1D,GACpBxC,EAAIgC,GAAchC,GACdiC,GAAgB,IAClB,OAAOG,GAA0BI,EAAGxC,EACxC,CAAI,MAAOhH,GAAsB,CAC/B,GAAI8B,GAAO0H,EAAGxC,GAAI,OAAO8C,IAA0BhJ,GAAKqM,GAA2B5D,EAAGC,EAAGxC,GAAIwC,EAAExC,GACjG,ECrBA,IAAI/D,GAAa/C,GACb8J,GAAuBpI,GACvBgK,GAAc7H,GACdN,GAAuBiD,GAE3B0G,GAAiB,SAAU5D,EAAGzH,EAAK2B,EAAOoI,GACnCA,IAASA,EAAU,IACxB,IAAIuB,EAASvB,EAAQnC,WACjBrH,OAAwBU,IAAjB8I,EAAQxJ,KAAqBwJ,EAAQxJ,KAAOP,EAEvD,GADIkB,GAAWS,IAAQkI,GAAYlI,EAAOpB,EAAMwJ,GAC5CA,EAAQ1I,OACNiK,EAAQ7D,EAAEzH,GAAO2B,EAChBD,GAAqB1B,EAAK2B,OAC1B,CACL,IACOoI,EAAQwB,OACJ9D,EAAEzH,KAAMsL,GAAS,UADE7D,EAAEzH,EAEpC,CAAM,MAAO/B,GAAsB,CAC3BqN,EAAQ7D,EAAEzH,GAAO2B,EAChBsG,GAAqBT,EAAEC,EAAGzH,EAAK,CAClC2B,MAAOA,EACPiG,YAAY,EACZnH,cAAesJ,EAAQyB,gBACvB5J,UAAWmI,EAAQ0B,aAEtB,CAAC,OAAOhE,CACX,QC1BIiE,GAAOtK,KAAKsK,KACZC,GAAQvK,KAAKuK,MCDbC,GDMaxK,KAAKwK,OAAS,SAAeC,GAC5C,IAAIC,GAAKD,EACT,OAAQC,EAAI,EAAIH,GAAQD,IAAMI,EAChC,ECLAC,GAAiB,SAAUnM,GACzB,IAAIoM,GAAUpM,EAEd,OAAOoM,GAAWA,GAAqB,IAAXA,EAAe,EAAIJ,GAAMI,EACvD,ECRID,GAAsB5N,GAEtB8N,GAAM7K,KAAK6K,IACXC,GAAM9K,KAAK8K,IAKfC,GAAiB,SAAUC,EAAO9I,GAChC,IAAI+I,EAAUN,GAAoBK,GAClC,OAAOC,EAAU,EAAIJ,GAAII,EAAU/I,EAAQ,GAAK4I,GAAIG,EAAS/I,EAC/D,ECXIyI,GAAsB5N,GAEtB+N,GAAM9K,KAAK8K,IAIfI,GAAiB,SAAU1M,GACzB,OAAOA,EAAW,EAAIsM,GAAIH,GAAoBnM,GAAW,kBAAoB,CAC/E,ECRI0M,GAAWnO,GAIfoO,GAAiB,SAAUC,GACzB,OAAOF,GAASE,EAAIlJ,OACtB,ECNI6H,GAAkBhN,GAClBgO,GAAkBtM,GAClB0M,GAAoBvK,GAGpByK,GAAe,SAAUC,GAC3B,OAAO,SAAUC,EAAOC,EAAIC,GAC1B,IAGIlL,EAHA8F,EAAI0D,GAAgBwB,GACpBrJ,EAASiJ,GAAkB9E,GAC3B2E,EAAQD,GAAgBU,EAAWvJ,GAIvC,GAAIoJ,GAAeE,GAAOA,GAAI,KAAOtJ,EAAS8I,GAG5C,IAFAzK,EAAQ8F,EAAE2E,OAEIzK,EAAO,OAAO,OAEvB,KAAM2B,EAAS8I,EAAOA,IAC3B,IAAKM,GAAeN,KAAS3E,IAAMA,EAAE2E,KAAWQ,EAAI,OAAOF,GAAeN,GAAS,EACnF,OAAQM,IAAgB,CAC9B,CACA,EAEAI,GAAiB,CAGfC,SAAUN,IAAa,GAGvBO,QAASP,IAAa,IC7BpB1M,GAASF,GACTsL,GAAkBnJ,GAClBgL,GAAUrI,GAAuCqI,QACjD1E,GAAarC,GAEbZ,GANclH,GAMK,GAAGkH,MAE1B4H,GAAiB,SAAU9E,EAAQ+E,GACjC,IAGIlN,EAHAyH,EAAI0D,GAAgBhD,GACpBgF,EAAI,EACJpG,EAAS,GAEb,IAAK/G,KAAOyH,GAAI1H,GAAOuI,GAAYtI,IAAQD,GAAO0H,EAAGzH,IAAQqF,GAAK0B,EAAQ/G,GAE1E,KAAOkN,EAAM5J,OAAS6J,GAAOpN,GAAO0H,EAAGzH,EAAMkN,EAAMC,SAChDH,GAAQjG,EAAQ/G,IAAQqF,GAAK0B,EAAQ/G,IAExC,OAAO+G,CACT,EClBAqG,GAAiB,CACf,cACA,iBACA,gBACA,uBACA,iBACA,WACA,WCREC,GAAqBlP,GAGrBmK,GAFczI,GAEWyN,OAAO,SAAU,aAKrCC,GAAA/F,EAAGpJ,OAAOoP,qBAAuB,SAA6B/F,GACrE,OAAO4F,GAAmB5F,EAAGa,GAC/B,ECVA,IAAAmF,GAAA,CAAA,EACSA,GAAAjG,EAAGpJ,OAAOgG,sBCDnB,IAAIjB,GAAahF,GAEbuP,GAA4B1L,GAC5B2L,GAA8BhJ,GAC9B1B,GAAWgD,GAEXqH,GALczN,GAKO,GAAGyN,QAG5BM,GAAiBzK,GAAW,UAAW,YAAc,SAAiB7D,GACpE,IAAI8I,EAAOsF,GAA0BlG,EAAEvE,GAAS3D,IAC5C8E,EAAwBuJ,GAA4BnG,EACxD,OAAOpD,EAAwBkJ,GAAOlF,EAAMhE,EAAsB9E,IAAO8I,CAC3E,ECbIrI,GAAS5B,GACTyP,GAAU/N,GACVgO,GAAiC7L,GACjCiG,GAAuBtD,GCHvB5G,GAAQI,GACR+C,GAAarB,GAEbiO,GAAc,kBAEdC,GAAW,SAAUC,EAASC,GAChC,IAAItM,EAAQuM,GAAKC,GAAUH,IAC3B,OAAOrM,IAAUyM,IACbzM,IAAU0M,KACVnN,GAAW+M,GAAalQ,GAAMkQ,KAC5BA,EACR,EAEIE,GAAYJ,GAASI,UAAY,SAAUG,GAC7C,OAAO9L,OAAO8L,GAAQ7E,QAAQqE,GAAa,KAAKS,aAClD,EAEIL,GAAOH,GAASG,KAAO,GACvBG,GAASN,GAASM,OAAS,IAC3BD,GAAWL,GAASK,SAAW,IAEnCI,GAAiBT,GCrBb1M,GAASlD,GACTgC,GAA2BN,GAA2D2H,EACtFU,GAA8BlG,GAC9BqJ,GAAgB1G,GAChBjD,GAAuBuE,GACvBwI,GFAa,SAAUpE,EAAQ5E,EAAQiJ,GAIzC,IAHA,IAAItG,EAAOwF,GAAQnI,GACfpH,EAAiB4J,GAAqBT,EACtCrH,EAA2B0N,GAA+BrG,EACrD2F,EAAI,EAAGA,EAAI/E,EAAK9E,OAAQ6J,IAAK,CACpC,IAAInN,EAAMoI,EAAK+E,GACVpN,GAAOsK,EAAQrK,IAAU0O,GAAc3O,GAAO2O,EAAY1O,IAC7D3B,EAAegM,EAAQrK,EAAKG,EAAyBsF,EAAQzF,GAEhE,CACH,EETI+N,GAAWvF,GAiBfmG,GAAiB,SAAU5E,EAAStE,GAClC,IAGY4E,EAAQrK,EAAK4O,EAAgBC,EAAgBvE,EAHrDwE,EAAS/E,EAAQM,OACjB0E,EAAShF,EAAQ1I,OACjB2N,EAASjF,EAAQkF,KASrB,GANE5E,EADE0E,EACO1N,GACA2N,EACA3N,GAAOyN,IAAWpN,GAAqBoN,EAAQ,CAAA,IAE9CzN,GAAOyN,IAAW,CAAA,GAAIhQ,UAEtB,IAAKkB,KAAOyF,EAAQ,CAQ9B,GAPAoJ,EAAiBpJ,EAAOzF,GAGtB4O,EAFE7E,EAAQmF,gBACV5E,EAAanK,GAAyBkK,EAAQrK,KACfsK,EAAW3I,MACpB0I,EAAOrK,IACtB+N,GAASgB,EAAS/O,EAAM8O,GAAUE,EAAS,IAAM,KAAOhP,EAAK+J,EAAQoF,cAE5ClO,IAAnB2N,EAA8B,CAC3C,UAAWC,UAAyBD,EAAgB,SACpDH,GAA0BI,EAAgBD,EAC3C,EAEG7E,EAAQxF,MAASqK,GAAkBA,EAAerK,OACpD2D,GAA4B2G,EAAgB,QAAQ,GAEtDxD,GAAchB,EAAQrK,EAAK6O,EAAgB9E,EAC5C,CACH,ECrDIsD,GAAqBlP,GACrBiP,GAAcvN,GAKlBuP,GAAiBhR,OAAOgK,MAAQ,SAAcX,GAC5C,OAAO4F,GAAmB5F,EAAG2F,GAC/B,ECRInN,GAAc9B,GACduH,GAAc7F,GACdd,GAAOiD,GACPjE,GAAQ4G,GACRyK,GAAanJ,GACb0H,GAA8BxH,GAC9BiF,GAA6B5C,GAC7B7I,GAAW8I,GACXyC,GAAgBmE,GAGhBC,GAAUlR,OAAOmR,OAEjBlR,GAAiBD,OAAOC,eACxBiP,GAAS5H,GAAY,GAAG4H,QAI5BkC,IAAkBF,IAAWvR,IAAM,WAEjC,GAAIkC,IAQiB,IARFqP,GAAQ,CAAEG,EAAG,GAAKH,GAAQjR,GAAe,CAAE,EAAE,IAAK,CACnEuJ,YAAY,EACZtJ,IAAK,WACHD,GAAeoD,KAAM,IAAK,CACxBE,MAAO,EACPiG,YAAY,GAEf,IACC,CAAE6H,EAAG,KAAMA,EAAS,OAAO,EAE/B,IAAIC,EAAI,CAAA,EACJC,EAAI,CAAA,EAEJtL,EAASC,OAAO,oBAChBsL,EAAW,uBAGf,OAFAF,EAAErL,GAAU,EACZuL,EAAS5L,MAAM,IAAI6L,SAAQ,SAAUC,GAAOH,EAAEG,GAAOA,CAAM,IACzB,IAA3BR,GAAQ,CAAA,EAAII,GAAGrL,IAAiB+K,GAAWE,GAAQ,CAAA,EAAIK,IAAIjG,KAAK,MAAQkG,CACjF,IAAK,SAAgBvF,EAAQ5E,GAM3B,IALA,IAAIsK,EAAIpQ,GAAS0K,GACb2F,EAAkB5Q,UAAUkE,OAC5B8I,EAAQ,EACRhI,EAAwBuJ,GAA4BnG,EACpDqD,EAAuBO,GAA2B5D,EAC/CwI,EAAkB5D,GAMvB,IALA,IAIIpM,EAJAiQ,EAAI/E,GAAc9L,UAAUgN,MAC5BhE,EAAOhE,EAAwBkJ,GAAO8B,GAAWa,GAAI7L,EAAsB6L,IAAMb,GAAWa,GAC5F3M,EAAS8E,EAAK9E,OACd4M,EAAI,EAED5M,EAAS4M,GACdlQ,EAAMoI,EAAK8H,KACNjQ,KAAelB,GAAK8L,EAAsBoF,EAAGjQ,KAAM+P,EAAE/P,GAAOiQ,EAAEjQ,IAErE,OAAO+P,CACX,EAAIT,GCtDAC,GAAS1P,GADL1B,GAMN,CAAEkM,OAAQ,SAAU4E,MAAM,EAAM/E,MAAO,EAAGiF,OAAQ/Q,OAAOmR,SAAWA,IAAU,CAC9EA,OAAQA,KCPV,IAGI/Q,GAAO,CAAA,EAEXA,GALsBL,GAEc,gBAGd,IAEtB,IAAAgS,GAAkC,eAAjB3N,OAAOhE,ICPpB4R,GAAwBjS,GACxB+C,GAAarB,GACbkL,GAAa/I,GAGbqO,GAFkB1L,GAEc,eAChCjF,GAAUtB,OAGVkS,GAAwE,cAApDvF,GAAW,WAAc,OAAO3L,SAAY,CAAjC,IAUnC4L,GAAiBoF,GAAwBrF,GAAa,SAAUzL,GAC9D,IAAImI,EAAG8I,EAAKxJ,EACZ,YAAc9F,IAAP3B,EAAmB,YAAqB,OAAPA,EAAc,OAEO,iBAAjDiR,EAXD,SAAUjR,EAAIU,GACzB,IACE,OAAOV,EAAGU,EACd,CAAI,MAAO/B,GAAsB,CACjC,CAOoBuS,CAAO/I,EAAI/H,GAAQJ,GAAK+Q,KAA8BE,EAEpED,GAAoBvF,GAAWtD,GAEF,YAA5BV,EAASgE,GAAWtD,KAAoBvG,GAAWuG,EAAEgJ,QAAU,YAAc1J,CACpF,EC3BIiE,GAAUnL,GCCVqC,GDFwB/D,GAKa,CAAA,EAAG+D,SAAW,WACrD,MAAO,WAAa8I,GAAQvJ,MAAQ,GACtC,ECP4BtD,IACR0B,GAMJzB,OAAOU,UAAW,WAAYoD,GAAU,CAAEqJ,QAAQ,ICPlE,IAGAmF,GAA6C,YAF/B7Q,GADD1B,GAGmByF,SCH5B8B,GAAcvH,GACd2G,GAAYjF,GCDZqB,GAAa/C,GAEb6E,GAAUR,OACVjD,GAAaC,UCFbmR,GFEa,SAAUxI,EAAQnI,EAAKqD,GACtC,IAEE,OAAOqC,GAAYZ,GAAU1G,OAAO+B,yBAAyBgI,EAAQnI,GAAKqD,IAC9E,CAAI,MAAOpF,GAAsB,CACjC,EENIgF,GAAWpD,GACX+Q,GDEa,SAAUhR,GACzB,GAAuB,iBAAZA,GAAwBsB,GAAWtB,GAAW,OAAOA,EAChE,MAAM,IAAIL,GAAW,aAAeyD,GAAQpD,GAAY,kBAC1D,ECCAiR,GAAiBzS,OAAO0S,iBAAmB,aAAe,CAAE,EAAG,WAC7D,IAEI7G,EAFA8G,GAAiB,EACjBvS,EAAO,CAAA,EAEX,KACEyL,EAAS0G,GAAoBvS,OAAOU,UAAW,YAAa,QACrDN,EAAM,IACbuS,EAAiBvS,aAAgBwS,KACrC,CAAI,MAAO/S,GAAsB,CAC/B,OAAO,SAAwBwJ,EAAGwJ,GAKhC,OAJAhO,GAASwE,GACTmJ,GAAmBK,GACfF,EAAgB9G,EAAOxC,EAAGwJ,GACzBxJ,EAAEyJ,UAAYD,EACZxJ,CACX,CACA,CAhB+D,QAgBzDxG,GCzBF5C,GAAiBF,GAA+CqJ,EAChEzH,GAASF,GAGTwQ,GAFkBrO,GAEc,eAEpCmP,GAAiB,SAAU9G,EAAQ+G,EAAKpC,GAClC3E,IAAW2E,IAAQ3E,EAASA,EAAOvL,WACnCuL,IAAWtK,GAAOsK,EAAQgG,KAC5BhS,GAAegM,EAAQgG,GAAe,CAAE5P,cAAc,EAAMkB,MAAOyP,GAEvE,ECXIjO,GAAahF,GACbiM,GAAwBvK,GAExBI,GAAc0E,GAEd0M,GAHkBrP,GAGQ,WAE9BsP,GAAiB,SAAUC,GACzB,IAAIC,EAAcrO,GAAWoO,GAEzBtR,IAAeuR,IAAgBA,EAAYH,KAC7CjH,GAAsBoH,EAAaH,GAAS,CAC1C5Q,cAAc,EACdnC,IAAK,WAAc,OAAOmD,IAAO,GAGvC,EChBI+B,GAAgBrF,GAEhBoB,GAAaC,UAEjBiS,GAAiB,SAAUnS,EAAIoS,GAC7B,GAAIlO,GAAckO,EAAWpS,GAAK,OAAOA,EACzC,MAAM,IAAIC,GAAW,uBACvB,ECPImG,GAAcvH,GACdJ,GAAQ8B,GACRqB,GAAac,GACbgJ,GAAUrG,GAEVxC,GAAgBgE,GAEhBwL,GAAO,WAAY,EACnBC,GAAQ,GACRC,GALa5L,GAKU,UAAW,aAClC6L,GAAoB,2BACpB9T,GAAO0H,GAAYoM,GAAkB9T,MACrC+T,IAAuBD,GAAkBtT,KAAKmT,IAE9CK,GAAsB,SAAuBpS,GAC/C,IAAKsB,GAAWtB,GAAW,OAAO,EAClC,IAEE,OADAiS,GAAUF,GAAMC,GAAOhS,IAChB,CACR,CAAC,MAAO3B,GACP,OAAO,CACR,CACH,EAEIgU,GAAsB,SAAuBrS,GAC/C,IAAKsB,GAAWtB,GAAW,OAAO,EAClC,OAAQoL,GAAQpL,IACd,IAAK,gBACL,IAAK,oBACL,IAAK,yBAA0B,OAAO,EAExC,IAIE,OAAOmS,MAAyB/T,GAAK8T,GAAmB3P,GAAcvC,GACvE,CAAC,MAAO3B,GACP,OAAO,CACR,CACH,EAEAgU,GAAoB1N,MAAO,EAI3B,ICtBI2N,GAAWC,GAAOC,GAASC,GDsB/BC,IAAkBT,IAAa9T,IAAM,WACnC,IAAIwU,EACJ,OAAOP,GAAoBA,GAAoBjT,QACzCiT,GAAoB5T,UACpB4T,IAAoB,WAAcO,GAAS,CAAK,KACjDA,CACP,IAAKN,GAAsBD,GEnDvBM,GAAgBnU,GAChB0G,GAAchF,GAEdN,GAAaC,UCHbyD,GAAW9E,GACXqU,GDKa,SAAU5S,GACzB,GAAI0S,GAAc1S,GAAW,OAAOA,EACpC,MAAM,IAAIL,GAAWsF,GAAYjF,GAAY,wBAC/C,ECPIP,GAAoB2C,GAGpBqP,GAFkB1M,GAEQ,WCL1BhG,GAAcR,GAEdS,GAAoBC,SAASC,UAC7BK,GAAQP,GAAkBO,MAC1BJ,GAAOH,GAAkBG,KAG7B0T,GAAmC,iBAAXC,SAAuBA,QAAQvT,QAAUR,GAAcI,GAAKN,KAAKU,IAAS,WAChG,OAAOJ,GAAKI,MAAMA,GAAOC,UAC3B,GCTI2L,GAAa5M,GACbuH,GAAc7F,GAElB8S,GAAiB,SAAUzT,GAIzB,GAAuB,aAAnB6L,GAAW7L,GAAoB,OAAOwG,GAAYxG,EACxD,ECPI4F,GAAYjF,GACZlB,GAAcqD,GAEdvD,GAJcN,MAIiBM,MAGnCmU,GAAiB,SAAU1T,EAAI2T,GAE7B,OADA/N,GAAU5F,QACM+B,IAAT4R,EAAqB3T,EAAKP,GAAcF,GAAKS,EAAI2T,GAAQ,WAC9D,OAAO3T,EAAGC,MAAM0T,EAAMzT,UAC1B,CACA,ECVA0T,GAFiB3U,GAEW,WAAY,mBCAxC4U,GAFkB5U,GAEW,GAAGqL,OCF5BjK,GAAaC,UCGjBwT,GAAiB,qCAAqCxU,KAHtCL,ITAZkD,GAASlD,GACTgB,GAAQU,GACRpB,GAAOuD,GACPd,GAAayD,GACb5E,GAASkG,GACTlI,GAAQoI,GACR2M,GAAOtK,GACPuK,GAAatK,GACb9F,GAAgB0M,GAChB4D,GQPa,SAAUC,EAAQC,GACjC,GAAID,EAASC,EAAU,MAAM,IAAI5T,GAAW,wBAC5C,OAAO2T,CACT,ERKIE,GAASC,GACTC,GAAUC,GAEV1L,GAAMxG,GAAOmS,aACbC,GAAQpS,GAAOqS,eACf9P,GAAUvC,GAAOuC,QACjB+P,GAAWtS,GAAOsS,SAClB9U,GAAWwC,GAAOxC,SAClB+U,GAAiBvS,GAAOuS,eACxBpR,GAASnB,GAAOmB,OAChBqR,GAAU,EACVC,GAAQ,CAAA,EACRC,GAAqB,qBAGzBhW,IAAM,WAEJmU,GAAY7Q,GAAO2S,QACrB,IAEA,IAAIC,GAAM,SAAUtO,GAClB,GAAI5F,GAAO+T,GAAOnO,GAAK,CACrB,IAAIzG,EAAK4U,GAAMnO,UACRmO,GAAMnO,GACbzG,GACD,CACH,EAEIgV,GAAS,SAAUvO,GACrB,OAAO,WACLsO,GAAItO,EACR,CACA,EAEIwO,GAAgB,SAAUC,GAC5BH,GAAIG,EAAMlG,KACZ,EAEImG,GAAyB,SAAU1O,GAErCtE,GAAOiT,YAAY9R,GAAOmD,GAAKuM,GAAUqC,SAAW,KAAOrC,GAAUsC,KACvE,EAGK3M,IAAQ4L,KACX5L,GAAM,SAAsB4M,GAC1BxB,GAAwB7T,UAAUkE,OAAQ,GAC1C,IAAIpE,EAAKgC,GAAWuT,GAAWA,EAAU5V,GAAS4V,GAC9CC,EAAO3B,GAAW3T,UAAW,GAKjC,OAJA0U,KAAQD,IAAW,WACjB1U,GAAMD,OAAI+B,EAAWyT,EAC3B,EACIvC,GAAM0B,IACCA,EACX,EACEJ,GAAQ,SAAwB9N,UACvBmO,GAAMnO,EACjB,EAEM2N,GACFnB,GAAQ,SAAUxM,GAChB/B,GAAQ+Q,SAAST,GAAOvO,GAC9B,EAEagO,IAAYA,GAASiB,IAC9BzC,GAAQ,SAAUxM,GAChBgO,GAASiB,IAAIV,GAAOvO,GAC1B,EAGaiO,KAAmBR,IAE5Bf,IADAD,GAAU,IAAIwB,IACCiB,MACfzC,GAAQ0C,MAAMC,UAAYZ,GAC1BhC,GAAQ1T,GAAK4T,GAAKiC,YAAajC,KAI/BhR,GAAO2T,kBACP9T,GAAWG,GAAOiT,eACjBjT,GAAO4T,eACR/C,IAAoC,UAAvBA,GAAUqC,WACtBxW,GAAMsW,KAEPlC,GAAQkC,GACRhT,GAAO2T,iBAAiB,UAAWb,IAAe,IAGlDhC,GADS4B,MAAsBpR,GAAc,UACrC,SAAUgD,GAChBmN,GAAKoC,YAAYvS,GAAc,WAAWoR,IAAsB,WAC9DjB,GAAKqC,YAAY1T,MACjBwS,GAAItO,EACZ,CACA,EAGY,SAAUA,GAChByP,WAAWlB,GAAOvO,GAAK,EAC7B,GAIA,IAAA0P,GAAiB,CACfxN,IAAKA,GACL4L,MAAOA,IUlHL6B,GAAQ,WACV7T,KAAK8T,KAAO,KACZ9T,KAAK+T,KAAO,IACd,EAEAF,GAAMxW,UAAY,CAChB2W,IAAK,SAAUC,GACb,IAAIC,EAAQ,CAAED,KAAMA,EAAME,KAAM,MAC5BJ,EAAO/T,KAAK+T,KACZA,EAAMA,EAAKI,KAAOD,EACjBlU,KAAK8T,KAAOI,EACjBlU,KAAK+T,KAAOG,CACb,EACDrX,IAAK,WACH,IAAIqX,EAAQlU,KAAK8T,KACjB,GAAII,EAGF,OADa,QADFlU,KAAK8T,KAAOI,EAAMC,QACVnU,KAAK+T,KAAO,MACxBG,EAAMD,IAEhB,GAGH,ICNIG,GAAQC,GAAQC,GAAMC,GAASC,GDMnCnC,GAAiBwB,GErBjBY,GAAiB,oBAAoB1X,KAFrBL,KAEyD,oBAAVgY,OCA/DC,GAAiB,qBAAqB5X,KAFtBL,IFAZkD,GAASlD,GACTM,GAAOoB,GACPM,GAA2B6B,GAA2DwF,EACtF6O,GAAY1R,GAA6BkD,IACzCyN,GAAQrP,GACRmN,GAASjN,GACTmQ,GAAgB9N,GAChB+N,GAAkB9N,GAClB6K,GAAUjE,GAEVmH,GAAmBnV,GAAOmV,kBAAoBnV,GAAOoV,uBACrD5V,GAAWQ,GAAOR,SAClB+C,GAAUvC,GAAOuC,QACjB8S,GAAUrV,GAAOqV,QAEjBC,GAA2BxW,GAAyBkB,GAAQ,kBAC5DuV,GAAYD,IAA4BA,GAAyBhV,MAIrE,IAAKiV,GAAW,CACd,IAAI9C,GAAQ,IAAIwB,GAEZuB,GAAQ,WACV,IAAIC,EAAQ5X,EAEZ,IADIoU,KAAYwD,EAASlT,GAAQmT,SAASD,EAAOE,OAC1C9X,EAAK4U,GAAMxV,WAChBY,GACD,CAAC,MAAOjB,GAEP,MADI6V,GAAMyB,MAAMM,KACV5X,CACP,CACG6Y,GAAQA,EAAOG,OACvB,EAIO7D,IAAWE,IAAYiD,KAAmBC,KAAoB3V,IAQvDyV,IAAiBI,IAAWA,GAAQQ,UAE9ClB,GAAUU,GAAQQ,aAAQjW,IAElBkJ,YAAcuM,GACtBT,GAAOxX,GAAKuX,GAAQC,KAAMD,IAC1BH,GAAS,WACPI,GAAKY,GACX,GAEavD,GACTuC,GAAS,WACPjS,GAAQ+Q,SAASkC,GACvB,GASIR,GAAY5X,GAAK4X,GAAWhV,IAC5BwU,GAAS,WACPQ,GAAUQ,GAChB,IAhCIf,IAAS,EACTC,GAAOlV,GAASsW,eAAe,IAC/B,IAAIX,GAAiBK,IAAOO,QAAQrB,GAAM,CAAEsB,eAAe,IAC3DxB,GAAS,WACPE,GAAK7H,KAAO4H,IAAUA,EAC5B,GA8BEc,GAAY,SAAU1X,GACf4U,GAAMyB,MAAMM,KACjB/B,GAAM2B,IAAIvW,EACd,CACA,CAEA,IAAAoY,GAAiBV,GG/EjBW,GAAiB,SAAUvZ,GACzB,IACE,MAAO,CAAEC,OAAO,EAAO0D,MAAO3D,IAC/B,CAAC,MAAOC,GACP,MAAO,CAAEA,OAAO,EAAM0D,MAAO1D,EAC9B,CACH,ECJAuZ,GAFarZ,GAEWuY,QCDxBe,GAAgC,iBAAR5T,MAAoBA,MAA+B,iBAAhBA,KAAKxB,QCEhEqV,IAHcvZ,KACA0B,IAGQ,iBAAV0B,QACY,iBAAZV,SCLRQ,GAASlD,GACTwZ,GAA2B9X,GAC3BqB,GAAac,GACb+L,GAAWpJ,GACXxC,GAAgB8D,GAChBM,GAAkBJ,GAClByR,GAAapP,GACbqP,GAAUpP,GAEVvE,GAAa4T,GAEYH,IAA4BA,GAAyB7Y,UAClF,IAAIuS,GAAU9K,GAAgB,WAC1BwR,IAAc,EACdC,GAAiC9W,GAAWG,GAAO4W,uBAEnDC,GAA6BnK,GAAS,WAAW,WACnD,IAAIoK,EAA6BhW,GAAcwV,IAC3CS,EAAyBD,IAA+B3V,OAAOmV,IAInE,IAAKS,GAAyC,KAAflU,GAAmB,OAAO,EAMzD,IAAKA,IAAcA,GAAa,KAAO,cAAc1F,KAAK2Z,GAA6B,CAErF,IAAInC,EAAU,IAAI2B,IAAyB,SAAUT,GAAWA,EAAQ,EAAG,IACvEmB,EAAc,SAAUra,GAC1BA,GAAK,WAAY,IAAiB,WAAY,GACpD,EAII,IAHkBgY,EAAQ7L,YAAc,IAC5BkH,IAAWgH,IACvBN,GAAc/B,EAAQC,MAAK,WAA2B,cAAaoC,GACjD,OAAO,CAE7B,CAAI,OAAQD,IAA2BR,IAAcC,MAAaG,EAClE,IAEAM,GAAiB,CACfC,YAAaL,GACbM,gBAAiBR,GACjBD,YAAaA,IC7CfU,GAAA,CAAA,EAAI3T,GAAY3G,GAEZoB,GAAaC,UAEbkZ,GAAoB,SAAUC,GAChC,IAAIzB,EAAS0B,EACbnX,KAAKuU,QAAU,IAAI2C,GAAE,SAAUE,EAAWC,GACxC,QAAgB7X,IAAZiW,QAAoCjW,IAAX2X,EAAsB,MAAM,IAAIrZ,GAAW,2BACxE2X,EAAU2B,EACVD,EAASE,CACb,IACErX,KAAKyV,QAAUpS,GAAUoS,GACzBzV,KAAKmX,OAAS9T,GAAU8T,EAC1B,EAIgBG,GAAAvR,EAAG,SAAUmR,GAC3B,OAAO,IAAID,GAAkBC,EAC/B,ECnBA,IAgDIK,GAAUC,GAAsCC,GAhDhDC,GAAIhb,GAEJmV,GAAUtR,GACVX,GAASsD,GACT5F,GAAOkH,GACPoF,GAAgBlF,GAChB2K,GAAiBtI,GACjB2I,GAAiB1I,GACjB6I,GAAajC,GACbvK,GAAYgT,GACZ5W,GAAamS,GACb5Q,GAAW8Q,GACX9B,GAAa2H,GACbC,GlBJa,SAAU5R,EAAG6R,GAC5B,IACIrJ,EADA0I,EAAI1V,GAASwE,GAAG0C,YAEpB,YAAalJ,IAAN0X,GAAmBtZ,GAAkB4Q,EAAIhN,GAAS0V,GAAGtH,KAAYiI,EAAqB9G,GAAavC,EAC5G,EkBCIoF,GAAOkE,GAA6B1R,IACpC+O,GAAY4C,GACZC,GChBa,SAAU3W,EAAG2M,GAC5B,IAEuB,IAArBrQ,UAAUkE,OAAeoW,QAAQzb,MAAM6E,GAAK4W,QAAQzb,MAAM6E,EAAG2M,EACjE,CAAI,MAAOxR,GAAsB,CACjC,EDYIsZ,GAAUoC,GACVrE,GAAQsE,GACRC,GAAsBC,GACtBnC,GAA2BoC,GAE3BC,GAA6BC,GAE7BC,GAAU,UACVhC,GAJ8BiC,GAI2B5B,YACzDP,GAL8BmC,GAK+B3B,gBAC7D4B,GAN8BD,GAM2BpC,YACzDsC,GAA0BR,GAAoB5Q,UAAUiR,IACxDI,GAAmBT,GAAoBhS,IACvC0S,GAAyB5C,IAA4BA,GAAyB7Y,UAC9E0b,GAAqB7C,GACrB8C,GAAmBF,GACnB/a,GAAY6B,GAAO7B,UACnBqB,GAAWQ,GAAOR,SAClB+C,GAAUvC,GAAOuC,QACjBmV,GAAuBiB,GAA2BxS,EAClDkT,GAA8B3B,GAE9B4B,MAAoB9Z,IAAYA,GAAS+Z,aAAevZ,GAAOwZ,eAC/DC,GAAsB,qBAWtBC,GAAa,SAAUzb,GACzB,IAAI2W,EACJ,SAAOxT,GAASnD,KAAO4B,GAAW+U,EAAO3W,EAAG2W,QAAQA,CACtD,EAEI+E,GAAe,SAAUC,EAAUtS,GACrC,IAMI5B,EAAQkP,EAAMiF,EANdvZ,EAAQgH,EAAMhH,MACdwZ,EAfU,IAeLxS,EAAMA,MACX8L,EAAU0G,EAAKF,EAASE,GAAKF,EAASG,KACtClE,EAAU+D,EAAS/D,QACnB0B,EAASqC,EAASrC,OAClB7B,EAASkE,EAASlE,OAEtB,IACMtC,GACG0G,IApBK,IAqBJxS,EAAM0S,WAAyBC,GAAkB3S,GACrDA,EAAM0S,UAvBA,IAyBQ,IAAZ5G,EAAkB1N,EAASpF,GAEzBoV,GAAQA,EAAOE,QACnBlQ,EAAS0N,EAAQ9S,GACboV,IACFA,EAAOC,OACPkE,GAAS,IAGTnU,IAAWkU,EAASjF,QACtB4C,EAAO,IAAIpZ,GAAU,yBACZyW,EAAO8E,GAAWhU,IAC3BhI,GAAKkX,EAAMlP,EAAQmQ,EAAS0B,GACvB1B,EAAQnQ,IACV6R,EAAOjX,EACf,CAAC,MAAO1D,GACH8Y,IAAWmE,GAAQnE,EAAOC,OAC9B4B,EAAO3a,EACR,CACH,EAEI4X,GAAS,SAAUlN,EAAO4S,GACxB5S,EAAM6S,WACV7S,EAAM6S,UAAW,EACjB5E,IAAU,WAGR,IAFA,IACIqE,EADAQ,EAAY9S,EAAM8S,UAEfR,EAAWQ,EAAUnd,OAC1B0c,GAAaC,EAAUtS,GAEzBA,EAAM6S,UAAW,EACbD,IAAa5S,EAAM0S,WAAWK,GAAY/S,EAClD,IACA,EAEIkS,GAAgB,SAAUta,EAAMyV,EAAS2F,GAC3C,IAAIvH,EAAOK,EACPkG,KACFvG,EAAQvT,GAAS+Z,YAAY,UACvB5E,QAAUA,EAChB5B,EAAMuH,OAASA,EACfvH,EAAMwH,UAAUrb,GAAM,GAAO,GAC7Bc,GAAOwZ,cAAczG,IAChBA,EAAQ,CAAE4B,QAASA,EAAS2F,OAAQA,IACtC3D,KAAmCvD,EAAUpT,GAAO,KAAOd,IAAQkU,EAAQL,GACvE7T,IAASua,IAAqBrB,GAAiB,8BAA+BkC,EACzF,EAEID,GAAc,SAAU/S,GAC1B5J,GAAKsW,GAAMhU,IAAQ,WACjB,IAGI0F,EAHAiP,EAAUrN,EAAME,OAChBlH,EAAQgH,EAAMhH,MAGlB,GAFmBka,GAAYlT,KAG7B5B,EAASwQ,IAAQ,WACXjE,GACF1P,GAAQkY,KAAK,qBAAsBna,EAAOqU,GACrC6E,GAAcC,GAAqB9E,EAASrU,EAC3D,IAEMgH,EAAM0S,UAAY/H,IAAWuI,GAAYlT,GArF/B,EADF,EAuFJ5B,EAAO9I,OAAO,MAAM8I,EAAOpF,KAErC,GACA,EAEIka,GAAc,SAAUlT,GAC1B,OA7FY,IA6FLA,EAAM0S,YAA0B1S,EAAMmO,MAC/C,EAEIwE,GAAoB,SAAU3S,GAChC5J,GAAKsW,GAAMhU,IAAQ,WACjB,IAAI2U,EAAUrN,EAAME,OAChByK,GACF1P,GAAQkY,KAAK,mBAAoB9F,GAC5B6E,GAzGa,mBAyGoB7E,EAASrN,EAAMhH,MAC3D,GACA,EAEIlD,GAAO,SAAUS,EAAIyJ,EAAOoT,GAC9B,OAAO,SAAUpa,GACfzC,EAAGyJ,EAAOhH,EAAOoa,EACrB,CACA,EAEIC,GAAiB,SAAUrT,EAAOhH,EAAOoa,GACvCpT,EAAMsT,OACVtT,EAAMsT,MAAO,EACTF,IAAQpT,EAAQoT,GACpBpT,EAAMhH,MAAQA,EACdgH,EAAMA,MArHO,EAsHbkN,GAAOlN,GAAO,GAChB,EAEIuT,GAAkB,SAAUvT,EAAOhH,EAAOoa,GAC5C,IAAIpT,EAAMsT,KAAV,CACAtT,EAAMsT,MAAO,EACTF,IAAQpT,EAAQoT,GACpB,IACE,GAAIpT,EAAME,SAAWlH,EAAO,MAAM,IAAInC,GAAU,oCAChD,IAAIyW,EAAO8E,GAAWpZ,GAClBsU,EACFW,IAAU,WACR,IAAIuF,EAAU,CAAEF,MAAM,GACtB,IACEld,GAAKkX,EAAMtU,EACTlD,GAAKyd,GAAiBC,EAASxT,GAC/BlK,GAAKud,GAAgBG,EAASxT,GAEjC,CAAC,MAAO1K,GACP+d,GAAeG,EAASle,EAAO0K,EAChC,CACT,KAEMA,EAAMhH,MAAQA,EACdgH,EAAMA,MA/II,EAgJVkN,GAAOlN,GAAO,GAEjB,CAAC,MAAO1K,GACP+d,GAAe,CAAEC,MAAM,GAAShe,EAAO0K,EACxC,CAzBsB,CA0BzB,EAGA,GAAIuP,KAcFuC,IAZAD,GAAqB,SAAiB4B,GACpC3K,GAAWhQ,KAAMgZ,IACjB3V,GAAUsX,GACVrd,GAAKia,GAAUvX,MACf,IAAIkH,EAAQ0R,GAAwB5Y,MACpC,IACE2a,EAAS3d,GAAKyd,GAAiBvT,GAAQlK,GAAKud,GAAgBrT,GAC7D,CAAC,MAAO1K,GACP+d,GAAerT,EAAO1K,EACvB,CACL,GAEwCa,WAGtCka,GAAW,SAAiBoD,GAC1B9B,GAAiB7Y,KAAM,CACrB0H,KAAM+Q,GACN+B,MAAM,EACNT,UAAU,EACV1E,QAAQ,EACR2E,UAAW,IAAInG,GACf+F,WAAW,EACX1S,MAlLQ,EAmLRhH,WAAOV,GAEb,GAIWnC,UAAYuM,GAAcoP,GAAkB,QAAQ,SAAc4B,EAAaC,GACtF,IAAI3T,EAAQ0R,GAAwB5Y,MAChCwZ,EAAWlC,GAAqBM,GAAmB5X,KAAM+Y,KAS7D,OARA7R,EAAMmO,QAAS,EACfmE,EAASE,IAAKja,GAAWmb,IAAeA,EACxCpB,EAASG,KAAOla,GAAWob,IAAeA,EAC1CrB,EAASlE,OAASzD,GAAU1P,GAAQmT,YAAS9V,EA/LnC,IAgMN0H,EAAMA,MAAmBA,EAAM8S,UAAUhG,IAAIwF,GAC5CrE,IAAU,WACboE,GAAaC,EAAUtS,EAC7B,IACWsS,EAASjF,OACpB,IAEEiD,GAAuB,WACrB,IAAIjD,EAAU,IAAIgD,GACdrQ,EAAQ0R,GAAwBrE,GACpCvU,KAAKuU,QAAUA,EACfvU,KAAKyV,QAAUzY,GAAKyd,GAAiBvT,GACrClH,KAAKmX,OAASna,GAAKud,GAAgBrT,EACvC,EAEEqR,GAA2BxS,EAAIuR,GAAuB,SAAUJ,GAC9D,OAAOA,IAAM6B,IA1MmB+B,YA0MG5D,EAC/B,IAAIM,GAAqBN,GACzB+B,GAA4B/B,EACpC,EAEkBzX,GAAWyW,KAA6B4C,KAA2Bnc,OAAOU,WAAW,CACnGoa,GAAaqB,GAAuBtE,KAE/BmE,IAEH/O,GAAckP,GAAwB,QAAQ,SAAc8B,EAAaC,GACvE,IAAIzJ,EAAOpR,KACX,OAAO,IAAI+Y,IAAmB,SAAUtD,EAAS0B,GAC/C7Z,GAAKma,GAAYrG,EAAMqE,EAAS0B,EACjC,IAAE3C,KAAKoG,EAAaC,EAE7B,GAAS,CAAE/Q,QAAQ,IAIf,WACSgP,GAAuBpQ,WACpC,CAAM,MAAOlM,GAAsB,CAG3B6S,IACFA,GAAeyJ,GAAwBE,GAE1C,CAGHtB,GAAE,CAAE9X,QAAQ,EAAM8I,aAAa,EAAMqS,MAAM,EAAMrN,OAAQ+I,IAA8B,CACrFxB,QAAS8D,KAGXrJ,GAAeqJ,GAAoBN,IAAS,GAC5C5I,GAAW4I,IE9RX,IAAAuC,GAAiB,CAAA,ECCbC,GAAY7c,GAEZ8c,GAHkBxe,GAGS,YAC3Bye,GAAiB5L,MAAMlS,UAG3B+d,GAAiB,SAAUvd,GACzB,YAAc2B,IAAP3B,IAAqBod,GAAU1L,QAAU1R,GAAMsd,GAAeD,MAAcrd,EACrF,ECTI0L,GAAU7M,GACV4G,GAAYlF,GACZR,GAAoB2C,GACpB0a,GAAY/X,GAGZgY,GAFkB1W,GAES,YAE/B6W,GAAiB,SAAUxd,GACzB,IAAKD,GAAkBC,GAAK,OAAOyF,GAAUzF,EAAIqd,KAC5C5X,GAAUzF,EAAI,eACdod,GAAU1R,GAAQ1L,GACzB,ECZIP,GAAOZ,GACP2G,GAAYjF,GACZoD,GAAWjB,GACX6C,GAAcF,GACdmY,GAAoB7W,GAEpB1G,GAAaC,UAEjBud,GAAiB,SAAUnd,EAAUod,GACnC,IAAIC,EAAiB7d,UAAUkE,OAAS,EAAIwZ,GAAkBld,GAAYod,EAC1E,GAAIlY,GAAUmY,GAAiB,OAAOha,GAASlE,GAAKke,EAAgBrd,IACpE,MAAM,IAAIL,GAAWsF,GAAYjF,GAAY,mBAC/C,ECZIb,GAAOZ,GACP8E,GAAWpD,GACXkF,GAAY/C,GAEhBkb,GAAiB,SAAUzY,EAAU0Y,EAAMxb,GACzC,IAAIyb,EAAaC,EACjBpa,GAASwB,GACT,IAEE,KADA2Y,EAAcrY,GAAUN,EAAU,WAChB,CAChB,GAAa,UAAT0Y,EAAkB,MAAMxb,EAC5B,OAAOA,CACR,CACDyb,EAAcre,GAAKqe,EAAa3Y,EACjC,CAAC,MAAOxG,GACPof,GAAa,EACbD,EAAcnf,CACf,CACD,GAAa,UAATkf,EAAkB,MAAMxb,EAC5B,GAAI0b,EAAY,MAAMD,EAEtB,OADAna,GAASma,GACFzb,CACT,ECtBIlD,GAAON,GACPY,GAAOc,GACPoD,GAAWjB,GACX6C,GAAcF,GACdkY,GAAwB5W,GACxBsG,GAAoBpG,GACpB3C,GAAgBgF,GAChBuU,GAActU,GACdqU,GAAoBzN,GACpB6N,GAAgBpF,GAEhBvY,GAAaC,UAEb8d,GAAS,SAAUC,EAASxW,GAC9BtF,KAAK8b,QAAUA,EACf9b,KAAKsF,OAASA,CAChB,EAEIyW,GAAkBF,GAAOxe,UAE7B2e,GAAiB,SAAUC,EAAUC,EAAiB5T,GACpD,IAMItF,EAAUmZ,EAAQxR,EAAO9I,EAAQyD,EAAQ6O,EAAMiI,EAN/ChL,EAAO9I,GAAWA,EAAQ8I,KAC1BiL,KAAgB/T,IAAWA,EAAQ+T,YACnCC,KAAehU,IAAWA,EAAQgU,WAClCC,KAAiBjU,IAAWA,EAAQiU,aACpCC,KAAiBlU,IAAWA,EAAQkU,aACpC/e,EAAKT,GAAKkf,EAAiB9K,GAG3BqL,EAAO,SAAUC,GAEnB,OADI1Z,GAAUyY,GAAczY,EAAU,SAAU0Z,GACzC,IAAIb,IAAO,EAAMa,EAC5B,EAEMC,EAAS,SAAUzc,GACrB,OAAImc,GACF7a,GAAStB,GACFsc,EAAc/e,EAAGyC,EAAM,GAAIA,EAAM,GAAIuc,GAAQhf,EAAGyC,EAAM,GAAIA,EAAM,KAChEsc,EAAc/e,EAAGyC,EAAOuc,GAAQhf,EAAGyC,EAChD,EAEE,GAAIoc,EACFtZ,EAAWiZ,EAASjZ,cACf,GAAIuZ,EACTvZ,EAAWiZ,MACN,CAEL,KADAE,EAASd,GAAkBY,IACd,MAAM,IAAIne,GAAWsF,GAAY6Y,GAAY,oBAE1D,GAAIb,GAAsBe,GAAS,CACjC,IAAKxR,EAAQ,EAAG9I,EAASiJ,GAAkBmR,GAAWpa,EAAS8I,EAAOA,IAEpE,IADArF,EAASqX,EAAOV,EAAStR,MACX5I,GAAcga,GAAiBzW,GAAS,OAAOA,EAC7D,OAAO,IAAIuW,IAAO,EACrB,CACD7Y,EAAWsY,GAAYW,EAAUE,EAClC,CAGD,IADAhI,EAAOmI,EAAYL,EAAS9H,KAAOnR,EAASmR,OACnCiI,EAAO9e,GAAK6W,EAAMnR,IAAWwX,MAAM,CAC1C,IACElV,EAASqX,EAAOP,EAAKlc,MACtB,CAAC,MAAO1D,GACPif,GAAczY,EAAU,QAASxG,EAClC,CACD,GAAqB,iBAAV8I,GAAsBA,GAAUvD,GAAcga,GAAiBzW,GAAS,OAAOA,CAC9F,CAAI,OAAO,IAAIuW,IAAO,EACtB,ECjEIX,GAFkBxe,GAES,YAC3BkgB,IAAe,EAEnB,IACE,IAAI9L,GAAS,EACT+L,GAAqB,CACvB1I,KAAM,WACJ,MAAO,CAAEqG,OAAQ1J,KAClB,EACDgM,OAAU,WACRF,IAAe,CAChB,GAEHC,GAAmB3B,IAAY,WAC7B,OAAOlb,IACX,EAEEuP,MAAMwN,KAAKF,IAAoB,WAAc,MAAM,CAAE,GACvD,CAAE,MAAOrgB,GAAsB,CAE/B,IAAAwgB,GAAiB,SAAUzgB,EAAM0gB,GAC/B,IACE,IAAKA,IAAiBL,GAAc,OAAO,CAC5C,CAAC,MAAOpgB,GAAS,OAAO,CAAQ,CACjC,IAAI0gB,GAAoB,EACxB,IACE,IAAIxW,EAAS,CAAA,EACbA,EAAOwU,IAAY,WACjB,MAAO,CACL/G,KAAM,WACJ,MAAO,CAAEqG,KAAM0C,GAAoB,EACpC,EAET,EACI3gB,EAAKmK,EACT,CAAI,MAAOlK,GAAsB,CAC/B,OAAO0gB,CACT,ECvCIhH,GAA2BxZ,GAI/BygB,GAFiC5c,GAAsDuW,cADrD1Y,IAG0C,SAAU6d,GACpF/F,GAAyB7W,IAAI4c,GAAUzH,UAAKhV,GAAW,WAAY,GACrE,ICLIlC,GAAOc,GACPiF,GAAY9C,GACZgY,GAA6BrV,GAC7B4S,GAAUtR,GACVwX,GAAUtX,GALNhI,GAUN,CAAEkM,OAAQ,UAAW4E,MAAM,EAAME,OAJO3G,IAIwC,CAChF1H,IAAK,SAAa4c,GAChB,IAAI/E,EAAIlX,KACJod,EAAa7E,GAA2BxS,EAAEmR,GAC1CzB,EAAU2H,EAAW3H,QACrB0B,EAASiG,EAAWjG,OACpB7R,EAASwQ,IAAQ,WACnB,IAAIuH,EAAkBha,GAAU6T,EAAEzB,SAC9B6H,EAAS,GACTlL,EAAU,EACVmL,EAAY,EAChBvB,GAAQC,GAAU,SAAU1H,GAC1B,IAAI5J,EAAQyH,IACRoL,GAAgB,EACpBD,IACAjgB,GAAK+f,EAAiBnG,EAAG3C,GAASC,MAAK,SAAUtU,GAC3Csd,IACJA,GAAgB,EAChBF,EAAO3S,GAASzK,IACdqd,GAAa9H,EAAQ6H,GACxB,GAAEnG,EACX,MACQoG,GAAa9H,EAAQ6H,EAC7B,IAEI,OADIhY,EAAO9I,OAAO2a,EAAO7R,EAAOpF,OACzBkd,EAAW7I,OACnB,ICpCH,IAAImD,GAAIhb,GAEJ+Z,GAA6BlW,GAAsDuW,YACnFZ,GAA2BhT,GAC3BxB,GAAa8C,GACb/E,GAAaiF,GACbkF,GAAgB7C,GAEhB+R,GAAyB5C,IAA4BA,GAAyB7Y,UAWlF,GAPAqa,GAAE,CAAE9O,OAAQ,UAAW4G,OAAO,EAAM9B,OAAQ+I,GAA4BgH,MAAM,GAAQ,CACpFC,MAAS,SAAU7C,GACjB,OAAO7a,KAAKwU,UAAKhV,EAAWqb,EAC7B,IAIapb,GAAWyW,IAA2B,CACpD,IAAItU,GAASF,GAAW,WAAWrE,UAAiB,MAChDyb,GAA8B,QAAMlX,IACtCgI,GAAckP,GAAwB,QAASlX,GAAQ,CAAEkI,QAAQ,GAErE,CCxBA,IACIxM,GAAOc,GACPiF,GAAY9C,GACZgY,GAA6BrV,GAC7B4S,GAAUtR,GACVwX,GAAUtX,GALNhI,GAUN,CAAEkM,OAAQ,UAAW4E,MAAM,EAAME,OAJO3G,IAIwC,CAChF4W,KAAM,SAAc1B,GAClB,IAAI/E,EAAIlX,KACJod,EAAa7E,GAA2BxS,EAAEmR,GAC1CC,EAASiG,EAAWjG,OACpB7R,EAASwQ,IAAQ,WACnB,IAAIuH,EAAkBha,GAAU6T,EAAEzB,SAClCuG,GAAQC,GAAU,SAAU1H,GAC1BjX,GAAK+f,EAAiBnG,EAAG3C,GAASC,KAAK4I,EAAW3H,QAAS0B,EACnE,GACA,IAEI,OADI7R,EAAO9I,OAAO2a,EAAO7R,EAAOpF,OACzBkd,EAAW7I,OACnB,ICvBH,IACIjX,GAAOc,GACPma,GAA6BhY,GAFzB7D,GAON,CAAEkM,OAAQ,UAAW4E,MAAM,EAAME,OAJFxK,GAAsD4T,aAId,CACvEK,OAAQ,SAAgByG,GACtB,IAAIR,EAAa7E,GAA2BxS,EAAE/F,MAE9C,OADA1C,GAAK8f,EAAWjG,YAAQ3X,EAAWoe,GAC5BR,EAAW7I,OACnB,ICZH,IAAI/S,GAAW9E,GACXsE,GAAW5C,GACXkZ,GAAuB/W,GCFvBmX,GAAIhb,GAIJ+Z,GAA6BjS,GAAsDsS,YACnF+G,GDDa,SAAU3G,EAAG9M,GAE5B,GADA5I,GAAS0V,GACLlW,GAASoJ,IAAMA,EAAE1B,cAAgBwO,EAAG,OAAO9M,EAC/C,IAAI0T,EAAoBxG,GAAqBvR,EAAEmR,GAG/C,OADAzB,EADcqI,EAAkBrI,SACxBrL,GACD0T,EAAkBvJ,OAC3B,ECViBnW,GAM0B,WAK3CsZ,GAAE,CAAE9O,OAAQ,UAAW4E,MAAM,EAAME,OAAmB+I,IAA8B,CAClFhB,QAAS,SAAiBrL,GACxB,OAAOyT,GAAgG7d,KAAMoK,EAC9G,ICfH,IAAA2T,GAAA,CAAA,EAAIvf,GAAc9B,GACdgJ,GAA0BtH,GAC1BoI,GAAuBjG,GACvBiB,GAAW0B,GACXwG,GAAkBlF,GAClBmJ,GAAajJ,GAKjBqZ,GAAAhY,EAAYvH,KAAgBkH,GAA0B/I,OAAOqhB,iBAAmB,SAA0BhY,EAAGiY,GAC3Gzc,GAASwE,GAMT,IALA,IAIIzH,EAJA2f,EAAQxU,GAAgBuU,GACxBtX,EAAOgH,GAAWsQ,GAClBpc,EAAS8E,EAAK9E,OACd8I,EAAQ,EAEL9I,EAAS8I,GAAOnE,GAAqBT,EAAEC,EAAGzH,EAAMoI,EAAKgE,KAAUuT,EAAM3f,IAC5E,OAAOyH,CACT,EClBA,IAmDImY,GAnDA3c,GAAW9E,GACX0hB,GAAyBhgB,GACzBuN,GAAcpL,GACdsG,GAAa3D,GACbmO,GAAO7M,GACPrD,GAAwBuD,GAKxB2Z,GAAY,YACZC,GAAS,SACTC,GANYxX,GAMS,YAErByX,GAAmB,WAAY,EAE/BC,GAAY,SAAUC,GACxB,MARO,IAQKJ,GATL,IASmBI,EAAnBC,KAAwCL,GATxC,GAUT,EAGIM,GAA4B,SAAUT,GACxCA,EAAgBU,MAAMJ,GAAU,KAChCN,EAAgBW,QAChB,IAAIC,EAAOZ,EAAgBa,aAAariB,OAExC,OADAwhB,EAAkB,KACXY,CACT,EAyBIE,GAAkB,WACpB,IACEd,GAAkB,IAAIe,cAAc,WACxC,CAAI,MAAO1iB,GAAuB,CAzBH,IAIzB2iB,EAFAC,EACAC,EAuBJJ,GAAqC,oBAAZ7f,SACrBA,SAASkW,QAAU6I,GACjBS,GAA0BT,KA1B5BiB,EAASje,GAAsB,UAC/Bke,EAAK,OAASf,GAAS,IAE3Bc,EAAOE,MAAMC,QAAU,OACvBlO,GAAKoC,YAAY2L,GAEjBA,EAAOI,IAAMze,OAAOse,IACpBF,EAAiBC,EAAOK,cAAcrgB,UACvBsgB,OACfP,EAAeN,MAAMJ,GAAU,sBAC/BU,EAAeL,QACRK,EAAeQ,GAiBlBf,GAA0BT,IAE9B,IADA,IAAItc,EAAS8J,GAAY9J,OAClBA,YAAiBod,GAAgBZ,IAAW1S,GAAY9J,IAC/D,OAAOod,IACT,EAEApY,GAAW0X,KAAY,MAKvBqB,GAAiBjjB,OAAOkjB,QAAU,SAAgB7Z,EAAGiY,GACnD,IAAI3Y,EAQJ,OAPU,OAANU,GACFwY,GAAiBH,IAAa7c,GAASwE,GACvCV,EAAS,IAAIkZ,GACbA,GAAiBH,IAAa,KAE9B/Y,EAAOiZ,IAAYvY,GACdV,EAAS2Z,UACMzf,IAAfye,EAA2B3Y,EAAS8Y,GAAuBrY,EAAET,EAAQ2Y,EAC9E,EClFInZ,GAAkBpI,GAClBmjB,GAASzhB,GACTxB,GAAiB2D,GAA+CwF,EAEhE+Z,GAAchb,GAAgB,eAC9BqW,GAAiB5L,MAAMlS,eAISmC,IAAhC2b,GAAe2E,KACjBljB,GAAeue,GAAgB2E,GAAa,CAC1C9gB,cAAc,EACdkB,MAAO2f,GAAO,YCEdE,GAAmBC,GAAmCC,GDG1DC,GAAiB,SAAU3hB,GACzB4c,GAAe2E,IAAavhB,IAAO,CACrC,EEjBA4hB,IAFYzjB,IAEY,WACtB,SAASijB,IAAmB,CAG5B,OAFAA,EAAEtiB,UAAUqL,YAAc,KAEnB/L,OAAOyjB,eAAe,IAAIT,KAASA,EAAEtiB,SAC9C,ICPIiB,GAAS5B,GACT+C,GAAarB,GACbF,GAAWqC,GAEX8f,GAA2B7b,GAE3B+Z,GAHYrb,GAGS,YACrBjF,GAAUtB,OACV2jB,GAAkBriB,GAAQZ,UAK9BkjB,GAAiBF,GAA2BpiB,GAAQmiB,eAAiB,SAAUpa,GAC7E,IAAIU,EAASxI,GAAS8H,GACtB,GAAI1H,GAAOoI,EAAQ6X,IAAW,OAAO7X,EAAO6X,IAC5C,IAAI7V,EAAchC,EAAOgC,YACzB,OAAIjJ,GAAWiJ,IAAgBhC,aAAkBgC,EACxCA,EAAYrL,UACZqJ,aAAkBzI,GAAUqiB,GAAkB,IACzD,EFpBIhkB,GAAQI,GACR+C,GAAarB,GACb4C,GAAWT,GAEX6f,GAAiB5b,GACjBoF,GAAgBlF,GAIhBwW,GAHkBnU,GAGS,YAC3ByZ,IAAyB,EAOzB,GAAG7Z,OAGC,SAFNsZ,GAAgB,GAAGtZ,SAIjBqZ,GAAoCI,GAAeA,GAAeH,QACxBtjB,OAAOU,YAAW0iB,GAAoBC,IAHlDQ,IAAyB,GAO3D,IAAIC,IAA0Bzf,GAAS+e,KAAsBzjB,IAAM,WACjE,IAAIS,EAAO,CAAA,EAEX,OAAOgjB,GAAkB7E,IAAU5d,KAAKP,KAAUA,CACpD,IAEI0jB,KAAwBV,GAAoB,IAK3CtgB,GAAWsgB,GAAkB7E,MAChCtR,GAAcmW,GAAmB7E,IAAU,WACzC,OAAOlb,IACX,IAGA,IAAA0gB,GAAiB,CACfX,kBAAmBA,GACnBS,uBAAwBA,IG9CtBT,GAAoBrjB,GAAuCqjB,kBAC3DF,GAASzhB,GACTkI,GAA2B/F,GAC3BmP,GAAiBxM,GACjB+X,GAAYzW,GAEZmc,GAAa,WAAc,OAAO3gB,MCNlC0X,GAAIhb,GACJY,GAAOc,GAGPqB,GAAa+E,GACboc,GDGa,SAAUC,EAAqBC,EAAM3M,EAAM4M,GAC1D,IAAInS,EAAgBkS,EAAO,YAI3B,OAHAD,EAAoBxjB,UAAYwiB,GAAOE,GAAmB,CAAE5L,KAAM7N,KAA2Bya,EAAiB5M,KAC9GzE,GAAemR,EAAqBjS,GAAe,GACnDqM,GAAUrM,GAAiB+R,GACpBE,CACT,ECRIT,GAAiBrZ,GACjBsI,GAAiBrI,GACjB0I,GAAiB9B,GACjBnH,GAA8B4P,GAC9BzM,GAAgBgI,GAEhBqJ,GAAYtD,GAGZqJ,GAZe9d,GAYqBrE,OACpC8I,GAbezE,GAa2BnE,aAC1CghB,GAJgBkB,GAIkBlB,kBAClCS,GALgBS,GAKuBT,uBACvCtF,GARkBpJ,GAQS,YAC3BoP,GAAO,OACPC,GAAS,SACTC,GAAU,UAEVT,GAAa,WAAc,OAAO3gB,MAEtCqhB,GAAiB,SAAUC,EAAUR,EAAMD,EAAqB1M,EAAMoN,EAASC,EAAQC,GACrFb,GAA0BC,EAAqBC,EAAM3M,GAErD,IAqBIuN,EAA0BC,EAASC,EArBnCC,EAAqB,SAAUC,GACjC,GAAIA,IAASP,GAAWQ,EAAiB,OAAOA,EAChD,IAAKvB,IAA0BsB,GAAQA,KAAQE,EAAmB,OAAOA,EAAkBF,GAE3F,OAAQA,GACN,KAAKZ,GACL,KAAKC,GACL,KAAKC,GAAS,OAAO,WAAqB,OAAO,IAAIP,EAAoB7gB,KAAM8hB,IAGjF,OAAO,WAAc,OAAO,IAAIjB,EAAoB7gB,KAAM,CAC9D,EAEM4O,EAAgBkS,EAAO,YACvBmB,GAAwB,EACxBD,EAAoBV,EAASjkB,UAC7B6kB,EAAiBF,EAAkB9G,KAClC8G,EAAkB,eAClBT,GAAWS,EAAkBT,GAC9BQ,GAAmBvB,IAA0B0B,GAAkBL,EAAmBN,GAClFY,EAA6B,UAATrB,GAAmBkB,EAAkBI,SAA4BF,EA+BzF,GA3BIC,IACFT,EAA2BtB,GAAe+B,EAAkB7kB,KAAK,IAAIgkB,OACpC3kB,OAAOU,WAAaqkB,EAAyBvN,OAC5DiM,GAAesB,KAA8B3B,KACvD1Q,GACFA,GAAeqS,EAA0B3B,IAC/BtgB,GAAWiiB,EAAyBxG,MAC9CtR,GAAc8X,EAA0BxG,GAAUyF,KAItDjR,GAAegS,EAA0B9S,GAAe,IAMxDoS,IAAwBO,IAAYJ,IAAUe,GAAkBA,EAAepjB,OAASqiB,KAC1ExZ,GACdlB,GAA4Bub,EAAmB,OAAQb,KAEvDc,GAAwB,EACxBF,EAAkB,WAAoB,OAAOzkB,GAAK4kB,EAAgBliB,SAKlEuhB,EAMF,GALAI,EAAU,CACRrE,OAAQuE,EAAmBV,IAC3Bxa,KAAM6a,EAASO,EAAkBF,EAAmBX,IACpDkB,QAASP,EAAmBT,KAE1BK,EAAQ,IAAKG,KAAOD,GAClBnB,IAA0ByB,KAA2BL,KAAOI,KAC9DpY,GAAcoY,EAAmBJ,EAAKD,EAAQC,SAE3ClK,GAAE,CAAE9O,OAAQkY,EAAMtR,OAAO,EAAM9B,OAAQ8S,IAA0ByB,GAAyBN,GASnG,OAL4BK,EAAkB9G,MAAc6G,GAC1DnY,GAAcoY,EAAmB9G,GAAU6G,EAAiB,CAAEjjB,KAAMyiB,IAEtEtG,GAAU6F,GAAQiB,EAEXJ,CACT,EClGAU,GAAiB,SAAUniB,EAAOsa,GAChC,MAAO,CAAEta,MAAOA,EAAOsa,KAAMA,EAC/B,ECJI9Q,GAAkBhN,GAClBwjB,GAAmB9hB,GACnB6c,GAAY1a,GACZ6X,GAAsBlV,GACtBtG,GAAiB4H,GAA+CuB,EAChEuc,GAAiB5d,GACjB2d,GAAyBtb,GAEzBvI,GAAcoP,GAEd2U,GAAiB,iBACjB1J,GAAmBT,GAAoBhS,IACvCyB,GAAmBuQ,GAAoB5Q,UAAU+a,IAYrDC,GAAiBF,GAAe/S,MAAO,SAAS,SAAUkT,EAAU/G,GAClE7C,GAAiB7Y,KAAM,CACrB0H,KAAM6a,GACN3Z,OAAQc,GAAgB+Y,GACxB9X,MAAO,EACP+Q,KAAMA,GAIV,IAAG,WACD,IAAIxU,EAAQW,GAAiB7H,MACzB4I,EAAS1B,EAAM0B,OACf+B,EAAQzD,EAAMyD,QAClB,IAAK/B,GAAU+B,GAAS/B,EAAO/G,OAE7B,OADAqF,EAAM0B,YAASpJ,EACR6iB,QAAuB7iB,GAAW,GAE3C,OAAQ0H,EAAMwU,MACZ,IAAK,OAAQ,OAAO2G,GAAuB1X,GAAO,GAClD,IAAK,SAAU,OAAO0X,GAAuBzZ,EAAO+B,IAAQ,GAC5D,OAAO0X,GAAuB,CAAC1X,EAAO/B,EAAO+B,KAAS,EAC1D,GAAG,UAKC2S,GAASrC,GAAUyH,UAAYzH,GAAU1L,MAQ7C,GALA2Q,GAAiB,QACjBA,GAAiB,UACjBA,GAAiB,WAGD1hB,IAA+B,WAAhB8e,GAAOxe,KAAmB,IACvDlC,GAAe0gB,GAAQ,OAAQ,CAAEpd,MAAO,UAC1C,CAAE,MAAO1D,IC5DT,IAAI+M,GAAU7M,GAEV6E,GAAUR,OAEdN,GAAiB,SAAUtC,GACzB,GAA0B,WAAtBoL,GAAQpL,GAAwB,MAAM,IAAIJ,UAAU,6CACxD,OAAOwD,GAAQpD,EACjB,ECPI8F,GAAcvH,GACd4N,GAAsBlM,GACtBqC,GAAWF,GACXvC,GAAyBkF,GAEzByf,GAAS1e,GAAY,GAAG0e,QACxBC,GAAa3e,GAAY,GAAG2e,YAC5B9a,GAAc7D,GAAY,GAAG8D,OAE7BiD,GAAe,SAAU6X,GAC3B,OAAO,SAAU3X,EAAO4X,GACtB,IAGIC,EAAOC,EAHPxU,EAAI/N,GAASzC,GAAuBkN,IACpC+X,EAAW3Y,GAAoBwY,GAC/BI,EAAO1U,EAAE3M,OAEb,OAAIohB,EAAW,GAAKA,GAAYC,EAAaL,EAAoB,QAAKrjB,GACtEujB,EAAQH,GAAWpU,EAAGyU,IACP,OAAUF,EAAQ,OAAUE,EAAW,IAAMC,IACtDF,EAASJ,GAAWpU,EAAGyU,EAAW,IAAM,OAAUD,EAAS,MAC3DH,EACEF,GAAOnU,EAAGyU,GACVF,EACFF,EACE/a,GAAY0G,EAAGyU,EAAUA,EAAW,GACVD,EAAS,OAAlCD,EAAQ,OAAU,IAA0B,KACzD,CACA,EC1BIJ,GD4Ba,CAGfQ,OAAQnY,IAAa,GAGrB2X,OAAQ3X,IAAa,IClC+B2X,OAClDliB,GAAWrC,GACXga,GAAsB7X,GACtB+hB,GAAiBpf,GACjBmf,GAAyB7d,GAEzB4e,GAAkB,kBAClBvK,GAAmBT,GAAoBhS,IACvCyB,GAAmBuQ,GAAoB5Q,UAAU4b,IAIrDd,GAAevhB,OAAQ,UAAU,SAAU0hB,GACzC5J,GAAiB7Y,KAAM,CACrB0H,KAAM0b,GACNvW,OAAQpM,GAASgiB,GACjB9X,MAAO,GAIX,IAAG,WACD,IAGI0Y,EAHAnc,EAAQW,GAAiB7H,MACzB6M,EAAS3F,EAAM2F,OACflC,EAAQzD,EAAMyD,MAElB,OAAIA,GAASkC,EAAOhL,OAAewgB,QAAuB7iB,GAAW,IACrE6jB,EAAQV,GAAO9V,EAAQlC,GACvBzD,EAAMyD,OAAS0Y,EAAMxhB,OACdwgB,GAAuBgB,GAAO,GACvC,IC7BA,IAAAC,GAAA,CAAApkB,QAAA,CAAA,GAAAqkB,GAAA,CAAA,EAAI/d,GAAgB9I,GAChB8J,GAAuBpI,GACvBkI,GAA2B/F,GAE/BijB,GAAiB,SAAU9c,EAAQnI,EAAK2B,GACtC,IAAIujB,EAAcje,GAAcjH,GAC5BklB,KAAe/c,EAAQF,GAAqBT,EAAEW,EAAQ+c,EAAand,GAAyB,EAAGpG,IAC9FwG,EAAO+c,GAAevjB,CAC7B,ECRIwK,GAAkBhO,GAClBoO,GAAoB1M,GACpBolB,GAAiBjjB,GAEjBmjB,GAASnU,MACT/E,GAAM7K,KAAK6K,IAEfmZ,GAAiB,SAAU3d,EAAG4d,EAAOC,GAMnC,IALA,IAAIhiB,EAASiJ,GAAkB9E,GAC3B8d,EAAIpZ,GAAgBkZ,EAAO/hB,GAC3BkiB,EAAMrZ,QAAwBlL,IAARqkB,EAAoBhiB,EAASgiB,EAAKhiB,GACxDyD,EAASoe,GAAOlZ,GAAIuZ,EAAMD,EAAG,IAC7BzZ,EAAI,EACDyZ,EAAIC,EAAKD,IAAKzZ,IAAKmZ,GAAele,EAAQ+E,EAAGrE,EAAE8d,IAEtD,OADAxe,EAAOzD,OAASwI,EACT/E,CACT,ECfIiE,GAAU7M,GACVgN,GAAkBtL,GAClB4lB,GAAuBzjB,GAAsDwF,EAC7EuL,GAAapO,GAEb+gB,GAA+B,iBAAVnkB,QAAsBA,QAAUnD,OAAOoP,oBAC5DpP,OAAOoP,oBAAoBjM,QAAU,GAWzCyjB,GAAAxd,EAAmB,SAA6BlI,GAC9C,OAAOomB,IAA+B,WAAhB1a,GAAQ1L,GAVX,SAAUA,GAC7B,IACE,OAAOmmB,GAAqBnmB,EAC7B,CAAC,MAAOrB,GACP,OAAO8U,GAAW2S,GACnB,CACH,CAKMC,CAAermB,GACfmmB,GAAqBta,GAAgB7L,GAC3C,ECrBA,IAEAsmB,GAFYznB,IAEW,WACrB,GAA0B,mBAAf0nB,YAA2B,CACpC,IAAIC,EAAS,IAAID,YAAY,GAEzBznB,OAAO2nB,aAAaD,IAAS1nB,OAAOC,eAAeynB,EAAQ,IAAK,CAAEnkB,MAAO,GAC9E,CACH,ICTI5D,GAAQI,GACRsE,GAAW5C,GACXmL,GAAUhJ,GACVgkB,GAA8BrhB,GAG9BshB,GAAgB7nB,OAAO2nB,aAK3BG,GAJ0BnoB,IAAM,WAAckoB,GAAc,EAAG,KAItBD,GAA+B,SAAsB1mB,GAC5F,QAAKmD,GAASnD,OACV0mB,IAA+C,gBAAhBhb,GAAQ1L,OACpC2mB,IAAgBA,GAAc3mB,IACvC,EAAI2mB,GCbJE,IAFYhoB,IAEY,WAEtB,OAAOC,OAAO2nB,aAAa3nB,OAAOgoB,kBAAkB,CAAA,GACtD,ICLIjN,GAAIhb,GACJuH,GAAc7F,GACdyI,GAAatG,GACbS,GAAWkC,GACX5E,GAASkG,GACT5H,GAAiB8H,GAA+CqB,EAChEkG,GAA4BlF,GAC5B6d,GAAoC5d,GACpCsd,GAAe1W,GAEfiX,GAAWjT,GAEXkT,IAAW,EACXC,GAJM1O,GAIS,QACfnS,GAAK,EAEL8gB,GAAc,SAAUnnB,GAC1BjB,GAAeiB,EAAIknB,GAAU,CAAE7kB,MAAO,CACpC+kB,SAAU,IAAM/gB,KAChBghB,SAAU,CAAE,IAEhB,EA4DIC,GAAOC,GAAAlmB,QAAiB,CAC1BmmB,OA3BW,WACXF,GAAKE,OAAS,aACdP,IAAW,EACX,IAAI/Y,EAAsBE,GAA0BlG,EAChDuf,EAASrhB,GAAY,GAAGqhB,QACxBvoB,EAAO,CAAA,EACXA,EAAKgoB,IAAY,EAGbhZ,EAAoBhP,GAAM8E,SAC5BoK,GAA0BlG,EAAI,SAAUlI,GAEtC,IADA,IAAIyH,EAASyG,EAAoBlO,GACxB6N,EAAI,EAAG7J,EAASyD,EAAOzD,OAAQ6J,EAAI7J,EAAQ6J,IAClD,GAAIpG,EAAOoG,KAAOqZ,GAAU,CAC1BO,EAAOhgB,EAAQoG,EAAG,GAClB,KACD,CACD,OAAOpG,CACf,EAEIoS,GAAE,CAAE9O,OAAQ,SAAU4E,MAAM,EAAME,QAAQ,GAAQ,CAChD3B,oBAAqB6Y,GAAkC7e,IAG7D,EAIEwf,QA5DY,SAAU1nB,EAAIgiB,GAE1B,IAAK7e,GAASnD,GAAK,MAAoB,iBAANA,EAAiBA,GAAmB,iBAANA,EAAiB,IAAM,KAAOA,EAC7F,IAAKS,GAAOT,EAAIknB,IAAW,CAEzB,IAAKT,GAAazmB,GAAK,MAAO,IAE9B,IAAKgiB,EAAQ,MAAO,IAEpBmF,GAAYnnB,EAEb,CAAC,OAAOA,EAAGknB,IAAUE,QACxB,EAiDEO,YA/CgB,SAAU3nB,EAAIgiB,GAC9B,IAAKvhB,GAAOT,EAAIknB,IAAW,CAEzB,IAAKT,GAAazmB,GAAK,OAAO,EAE9B,IAAKgiB,EAAQ,OAAO,EAEpBmF,GAAYnnB,EAEb,CAAC,OAAOA,EAAGknB,IAAUG,QACxB,EAsCEO,SAnCa,SAAU5nB,GAEvB,OADIgnB,IAAYC,IAAYR,GAAazmB,KAAQS,GAAOT,EAAIknB,KAAWC,GAAYnnB,GAC5EA,CACT,GAmCAgJ,GAAWke,KAAY,oBCxFnBtlB,GAAa/C,GACbsE,GAAW5C,GACXiR,GAAiB9O,GCFjBmX,GAAIhb,GACJkD,GAASxB,GACT6F,GAAc1D,GACd+L,GAAWpJ,GACX0G,GAAgBpF,GAChBkhB,GAAyBhhB,GACzBsX,GAAUjV,GACViJ,GAAahJ,GACbvH,GAAamO,GACbhQ,GAAoByY,GACpBrV,GAAW4Q,GACXtV,GAAQwV,GACRkL,GAA8BrF,GAC9BjI,GAAiBuR,GACjB0E,GDTa,SAAUza,EAAO0a,EAAOC,GACvC,IAAIC,EAAWC,EAUf,OAPE1W,IAEA5P,GAAWqmB,EAAYF,EAAMld,cAC7Bod,IAAcD,GACd7kB,GAAS+kB,EAAqBD,EAAUzoB,YACxC0oB,IAAuBF,EAAQxoB,WAC/BgS,GAAenE,EAAO6a,GACjB7a,CACT,ECDA8a,GAAiB,SAAUlW,EAAkB4K,EAASuL,GACpD,IAAIC,GAA8C,IAArCpW,EAAiBvE,QAAQ,OAClC4a,GAAgD,IAAtCrW,EAAiBvE,QAAQ,QACnC6a,EAAQF,EAAS,MAAQ,MACzBG,EAAoBzmB,GAAOkQ,GAC3BwW,EAAkBD,GAAqBA,EAAkBhpB,UACzD0S,EAAcsW,EACdE,EAAW,CAAA,EAEXC,EAAY,SAAU5E,GACxB,IAAI6E,EAAwBxiB,GAAYqiB,EAAgB1E,IACxDhY,GAAc0c,EAAiB1E,EACrB,QAARA,EAAgB,SAAa1hB,GAE3B,OADAumB,EAAsBzmB,KAAgB,IAAVE,EAAc,EAAIA,GACvCF,IACf,EAAkB,WAAR4hB,EAAmB,SAAUrjB,GAC/B,QAAO4nB,IAAYnlB,GAASzC,KAAekoB,EAAsBzmB,KAAc,IAARzB,EAAY,EAAIA,EACxF,EAAW,QAARqjB,EAAgB,SAAarjB,GAC/B,OAAO4nB,IAAYnlB,GAASzC,QAAOiB,EAAYinB,EAAsBzmB,KAAc,IAARzB,EAAY,EAAIA,EAC5F,EAAW,QAARqjB,EAAgB,SAAarjB,GAC/B,QAAO4nB,IAAYnlB,GAASzC,KAAekoB,EAAsBzmB,KAAc,IAARzB,EAAY,EAAIA,EAC/F,EAAU,SAAaA,EAAK2B,GAEpB,OADAumB,EAAsBzmB,KAAc,IAARzB,EAAY,EAAIA,EAAK2B,GAC1CF,IACR,EAEP,EASE,GAPcsM,GACZwD,GACCrQ,GAAW4mB,MAAwBF,GAAWG,EAAgBlY,UAAY9R,IAAM,YAC/E,IAAI+pB,GAAoBjE,UAAUjO,MACxC,MAKIpE,EAAckW,EAAOS,eAAehM,EAAS5K,EAAkBoW,EAAQE,GACvEV,GAAuBL,cAClB,GAAI/Y,GAASwD,GAAkB,GAAO,CAC3C,IAAI6W,EAAW,IAAI5W,EAEf6W,EAAiBD,EAASP,GAAOD,EAAU,CAAE,GAAI,EAAG,KAAOQ,EAE3DE,EAAuBvqB,IAAM,WAAcqqB,EAAStgB,IAAI,EAAG,IAG3DygB,EAAmB9J,IAA4B,SAAUf,GAAY,IAAIoK,EAAkBpK,EAAU,IAErG8K,GAAcZ,GAAW7pB,IAAM,WAIjC,IAFA,IAAI0qB,EAAY,IAAIX,EAChB1b,EAAQ,EACLA,KAASqc,EAAUZ,GAAOzb,EAAOA,GACxC,OAAQqc,EAAU3gB,KAAK,EAC7B,IAESygB,KACH/W,EAAc2K,GAAQ,SAAUkL,EAAO3J,GACrCjM,GAAW4V,EAAOU,GAClB,IAAIlV,EAAOuU,GAAkB,IAAIU,EAAqBT,EAAO7V,GAE7D,OADKnS,GAAkBqe,IAAWD,GAAQC,EAAU7K,EAAKgV,GAAQ,CAAEhV,KAAMA,EAAMiL,WAAY6J,IACpF9U,CACf,KACkB/T,UAAYipB,EACxBA,EAAgB5d,YAAcqH,IAG5B8W,GAAwBE,KAC1BP,EAAU,UACVA,EAAU,OACVN,GAAUM,EAAU,SAGlBO,GAAcH,IAAgBJ,EAAUJ,GAGxCD,GAAWG,EAAgBtU,cAAcsU,EAAgBtU,KAC9D,CASD,OAPAuU,EAASzW,GAAoBC,EAC7B2H,GAAE,CAAE9X,QAAQ,EAAM8I,aAAa,EAAMgF,OAAQqC,IAAgBsW,GAAqBE,GAElF7W,GAAeK,EAAaD,GAEvBqW,GAASF,EAAOgB,UAAUlX,EAAaD,EAAkBoW,GAEvDnW,CACT,ECxGInG,GAAgBlN,GAEpBwqB,GAAiB,SAAUte,EAAQ4W,EAAKlX,GACtC,IAAK,IAAI/J,KAAOihB,EAAK5V,GAAchB,EAAQrK,EAAKihB,EAAIjhB,GAAM+J,GAC1D,OAAOM,CACT,ECLIW,GAAU7M,GAKdyqB,GAAiB5X,MAAM4X,SAAW,SAAiBhpB,GACjD,MAA6B,UAAtBoL,GAAQpL,EACjB,ECPIgpB,GAAUzqB,GACVmU,GAAgBzS,GAChB4C,GAAWT,GAGXqP,GAFkB1M,GAEQ,WAC1BwgB,GAASnU,MCNT6X,GDUa,SAAUC,GACzB,IAAInQ,EASF,OAREiQ,GAAQE,KACVnQ,EAAImQ,EAAc3e,aAEdmI,GAAcqG,KAAOA,IAAMwM,IAAUyD,GAAQjQ,EAAE7Z,aAC1C2D,GAASkW,IAEN,QADVA,EAAIA,EAAEtH,QAFwDsH,OAAI1X,SAKvDA,IAAN0X,EAAkBwM,GAASxM,CACtC,ECjBAoQ,GAAiB,SAAUD,EAAexlB,GACxC,OAAO,IAAKulB,GAAwBC,GAA7B,CAAwD,IAAXxlB,EAAe,EAAIA,EACzE,ECNI7E,GAAON,GAEP+M,GAAgBlJ,GAChBrC,GAAWgF,GACX4H,GAAoBtG,GACpB8iB,GAAqB5iB,GAErBd,GANcxF,GAMK,GAAGwF,MAGtBoH,GAAe,SAAUvD,GAC3B,IAAIye,EAAkB,IAATze,EACT8f,EAAqB,IAAT9f,EACZ+f,EAAmB,IAAT/f,EACVggB,EAAoB,IAAThgB,EACXigB,EAAyB,IAATjgB,EAChBkgB,EAA4B,IAATlgB,EACnBmgB,EAAoB,IAATngB,GAAcigB,EAC7B,OAAO,SAAUxc,EAAO2c,EAAYzW,EAAM0W,GASxC,IARA,IAOI5nB,EAAOoF,EAPPU,EAAI9H,GAASgN,GACbnL,EAAO0J,GAAczD,GACrBnE,EAASiJ,GAAkB/K,GAC3BgoB,EAAgB/qB,GAAK6qB,EAAYzW,GACjCzG,EAAQ,EACRkV,EAASiI,GAAkBR,GAC3B1e,EAASsd,EAASrG,EAAO3U,EAAOrJ,GAAU0lB,GAAaI,EAAmB9H,EAAO3U,EAAO,QAAK1L,EAE3FqC,EAAS8I,EAAOA,IAAS,IAAIid,GAAYjd,KAAS5K,KAEtDuF,EAASyiB,EADT7nB,EAAQH,EAAK4K,GACiBA,EAAO3E,GACjCyB,GACF,GAAIye,EAAQtd,EAAO+B,GAASrF,OACvB,GAAIA,EAAQ,OAAQmC,GACvB,KAAK,EAAG,OAAO,EACf,KAAK,EAAG,OAAOvH,EACf,KAAK,EAAG,OAAOyK,EACf,KAAK,EAAG/G,GAAKgF,EAAQ1I,QAChB,OAAQuH,GACb,KAAK,EAAG,OAAO,EACf,KAAK,EAAG7D,GAAKgF,EAAQ1I,GAI3B,OAAOwnB,GAAiB,EAAIF,GAAWC,EAAWA,EAAW7e,CACjE,CACA,EAEAof,GAAiB,CAGf5Z,QAASpD,GAAa,GAGtBid,IAAKjd,GAAa,GAGlBkd,OAAQld,GAAa,GAGrBmd,KAAMnd,GAAa,GAGnBod,MAAOpd,GAAa,GAGpBqd,KAAMrd,GAAa,GAGnBsd,UAAWtd,GAAa,GAGxBud,aAAcvd,GAAa,ICvEzB/G,GAAcvH,GACdwqB,GAAiB9oB,GACjBonB,GAAcjlB,GAA0CilB,YACxDxV,GAAa9M,GACb1B,GAAWgD,GACX5G,GAAoB8G,GACpB1D,GAAW+F,GACXiV,GAAUhV,GAEV1I,GAAS+X,GAGTwC,GAFsBjH,GAEiBxL,IACvCoiB,GAHsB5W,GAGuBpK,UAC7C6gB,GANuBza,GAMKya,KAC5BC,GAPuB1a,GAOU0a,UACjChD,GAASrhB,GAAY,GAAGqhB,QACxBphB,GAAK,EAGLukB,GAAsB,SAAUvhB,GAClC,OAAOA,EAAMwhB,SAAWxhB,EAAMwhB,OAAS,IAAIC,GAC7C,EAEIA,GAAsB,WACxB3oB,KAAKoiB,QAAU,EACjB,EAEIwG,GAAqB,SAAUtoB,EAAO/B,GACxC,OAAO8pB,GAAK/nB,EAAM8hB,SAAS,SAAUvkB,GACnC,OAAOA,EAAG,KAAOU,CACrB,GACA,EAEAoqB,GAAoBtrB,UAAY,CAC9BR,IAAK,SAAU0B,GACb,IAAI2V,EAAQ0U,GAAmB5oB,KAAMzB,GACrC,GAAI2V,EAAO,OAAOA,EAAM,EACzB,EACD7N,IAAK,SAAU9H,GACb,QAASqqB,GAAmB5oB,KAAMzB,EACnC,EACD6H,IAAK,SAAU7H,EAAK2B,GAClB,IAAIgU,EAAQ0U,GAAmB5oB,KAAMzB,GACjC2V,EAAOA,EAAM,GAAKhU,EACjBF,KAAKoiB,QAAQxe,KAAK,CAACrF,EAAK2B,GAC9B,EACD2oB,OAAU,SAAUtqB,GAClB,IAAIoM,EAAQ2d,GAAUtoB,KAAKoiB,SAAS,SAAUvkB,GAC5C,OAAOA,EAAG,KAAOU,CACvB,IAEI,OADKoM,GAAO2a,GAAOtlB,KAAKoiB,QAASzX,EAAO,MAC9BA,CACX,GAGH,IAAAme,GAAiB,CACfpC,eAAgB,SAAUhM,EAAS5K,EAAkBoW,EAAQE,GAC3D,IAAIrW,EAAc2K,GAAQ,SAAUtJ,EAAM6K,GACxCjM,GAAWoB,EAAMnB,GACjB4I,GAAiBzH,EAAM,CACrB1J,KAAMoI,EACN5L,GAAIA,KACJwkB,YAAQlpB,IAEL5B,GAAkBqe,IAAWD,GAAQC,EAAU7K,EAAKgV,GAAQ,CAAEhV,KAAMA,EAAMiL,WAAY6J,GACjG,IAEQjW,EAAYF,EAAY1S,UAExBwK,EAAmB2gB,GAAuB1Y,GAE1CiZ,EAAS,SAAU3X,EAAM7S,EAAK2B,GAChC,IAAIgH,EAAQW,EAAiBuJ,GACzB3E,EAAO+Y,GAAYhkB,GAASjD,IAAM,GAGtC,OAFa,IAATkO,EAAegc,GAAoBvhB,GAAOd,IAAI7H,EAAK2B,GAClDuM,EAAKvF,EAAMhD,IAAMhE,EACfkR,CACb,EAiDI,OA/CA8V,GAAejX,EAAW,CAIxB4Y,OAAU,SAAUtqB,GAClB,IAAI2I,EAAQW,EAAiB7H,MAC7B,IAAKgB,GAASzC,GAAM,OAAO,EAC3B,IAAIkO,EAAO+Y,GAAYjnB,GACvB,OAAa,IAATkO,EAAsBgc,GAAoBvhB,GAAe,OAAE3I,GACxDkO,GAAQnO,GAAOmO,EAAMvF,EAAMhD,YAAcuI,EAAKvF,EAAMhD,GAC5D,EAIDmC,IAAK,SAAa9H,GAChB,IAAI2I,EAAQW,EAAiB7H,MAC7B,IAAKgB,GAASzC,GAAM,OAAO,EAC3B,IAAIkO,EAAO+Y,GAAYjnB,GACvB,OAAa,IAATkO,EAAsBgc,GAAoBvhB,GAAOb,IAAI9H,GAClDkO,GAAQnO,GAAOmO,EAAMvF,EAAMhD,GACnC,IAGHgjB,GAAejX,EAAWiW,EAAS,CAGjCrpB,IAAK,SAAa0B,GAChB,IAAI2I,EAAQW,EAAiB7H,MAC7B,GAAIgB,GAASzC,GAAM,CACjB,IAAIkO,EAAO+Y,GAAYjnB,GACvB,OAAa,IAATkO,EAAsBgc,GAAoBvhB,GAAOrK,IAAI0B,GAClDkO,EAAOA,EAAKvF,EAAMhD,SAAM1E,CAChC,CACF,EAGD4G,IAAK,SAAa7H,EAAK2B,GACrB,OAAO6oB,EAAO/oB,KAAMzB,EAAK2B,EAC1B,GACC,CAGF8T,IAAK,SAAa9T,GAChB,OAAO6oB,EAAO/oB,KAAME,GAAO,EAC5B,IAGI6P,CACR,GChIcrT,GAKN,WAAW,SAAUssB,GAC9B,OAAO,WAAqB,OAAOA,EAAKhpB,KAAMrC,UAAUkE,OAASlE,UAAU,QAAK6B,EAAW,CAC7F,GANqBpB,ICCrB,IAAA6qB,GAAiB,CACfC,YAAa,EACbC,oBAAqB,EACrBC,aAAc,EACdC,eAAgB,EAChBC,YAAa,EACbC,cAAe,EACfC,aAAc,EACdC,qBAAsB,EACtBC,SAAU,EACVC,kBAAmB,EACnBC,eAAgB,EAChBC,gBAAiB,EACjBC,kBAAmB,EACnBC,UAAW,EACXC,cAAe,EACfC,aAAc,EACdC,SAAU,EACVC,iBAAkB,EAClBC,OAAQ,EACRC,YAAa,EACbC,cAAe,EACfC,cAAe,EACfC,eAAgB,EAChBC,aAAc,EACdC,cAAe,EACfC,iBAAkB,EAClBC,iBAAkB,EAClBC,eAAgB,EAChBC,iBAAkB,EAClBC,cAAe,EACfC,UAAW,GC9BTC,GAFwBvuB,GAEU,QAAQuuB,UAC1CC,GAAwBD,IAAaA,GAAUviB,aAAeuiB,GAAUviB,YAAYrL,UAExF8tB,GAAiBD,KAA0BvuB,OAAOU,eAAYmC,EAAY0rB,GCNtEtrB,GAASlD,GACT0uB,GAAehtB,GACf8sB,GAAwB3qB,GACxB8qB,GAAuBnoB,GACvBuD,GAA8BjC,GAC9BkL,GAAiBhL,GAGjBwW,GAFkBnU,GAES,YAC3BukB,GAAcD,GAAqB/N,OAEnCiO,GAAkB,SAAUC,EAAqBC,GACnD,GAAID,EAAqB,CAEvB,GAAIA,EAAoBtQ,MAAcoQ,GAAa,IACjD7kB,GAA4B+kB,EAAqBtQ,GAAUoQ,GAC5D,CAAC,MAAO9uB,GACPgvB,EAAoBtQ,IAAYoQ,EACjC,CAED,GADA5b,GAAe8b,EAAqBC,GAAiB,GACjDL,GAAaK,GAAkB,IAAK,IAAIC,KAAeL,GAEzD,GAAIG,EAAoBE,KAAiBL,GAAqBK,GAAc,IAC1EjlB,GAA4B+kB,EAAqBE,EAAaL,GAAqBK,GACpF,CAAC,MAAOlvB,GACPgvB,EAAoBE,GAAeL,GAAqBK,EACzD,CAEJ,CACH,EAEA,IAAK,IAAID,MAAmBL,GAC1BG,GAAgB3rB,GAAO6rB,KAAoB7rB,GAAO6rB,IAAiBpuB,UAAWouB,IAGhFF,GAAgBL,GAAuB,gBCnCvC,IAAI5uB,GAAQI,GAER+F,GAAalC,GAEbqP,GAHkBxR,GAGQ,WAE9ButB,GAAiB,SAAUD,GAIzB,OAAOjpB,IAAc,KAAOnG,IAAM,WAChC,IAAIsvB,EAAQ,GAKZ,OAJkBA,EAAMljB,YAAc,IAC1BkH,IAAW,WACrB,MAAO,CAAEic,IAAK,EACpB,EAC+C,IAApCD,EAAMF,GAAaI,SAASD,GACvC,GACA,EClBInU,GAAIhb,GACJyqB,GAAU/oB,GACVyS,GAAgBtQ,GAChBS,GAAWkC,GACXwH,GAAkBlG,GAClBsG,GAAoBpG,GACpBgF,GAAkB3C,GAClByc,GAAiBxc,GACjBlC,GAAkB8I,GAElBme,GAAcna,GAEdoa,GAH+B3V,GAGoB,SAEnDzG,GAAU9K,GAAgB,WAC1B4e,GAASnU,MACT/E,GAAM7K,KAAK6K,IAKfkN,GAAE,CAAE9O,OAAQ,QAAS4G,OAAO,EAAM9B,QAASse,IAAuB,CAChEjkB,MAAO,SAAe6b,EAAOC,GAC3B,IAKI9T,EAAazK,EAAQ+E,EALrBrE,EAAI0D,GAAgB1J,MACpB6B,EAASiJ,GAAkB9E,GAC3B8d,EAAIpZ,GAAgBkZ,EAAO/hB,GAC3BkiB,EAAMrZ,QAAwBlL,IAARqkB,EAAoBhiB,EAASgiB,EAAKhiB,GAG5D,GAAIslB,GAAQnhB,KACV+J,EAAc/J,EAAE0C,aAEZmI,GAAcd,KAAiBA,IAAgB2T,IAAUyD,GAAQpX,EAAY1S,aAEtE2D,GAAS+O,IAEE,QADpBA,EAAcA,EAAYH,QAF1BG,OAAcvQ,GAKZuQ,IAAgB2T,SAA0BlkB,IAAhBuQ,GAC5B,OAAOgc,GAAY/lB,EAAG8d,EAAGC,GAI7B,IADAze,EAAS,SAAqB9F,IAAhBuQ,EAA4B2T,GAAS3T,GAAavF,GAAIuZ,EAAMD,EAAG,IACxEzZ,EAAI,EAAGyZ,EAAIC,EAAKD,IAAKzZ,IAASyZ,KAAK9d,GAAGwd,GAAele,EAAQ+E,EAAGrE,EAAE8d,IAEvE,OADAxe,EAAOzD,OAASwI,EACT/E,CACR,IC9CH,IAAIhJ,GAAQI,GAEZuvB,GAAiB,SAAUP,EAAavtB,GACtC,IAAIyD,EAAS,GAAG8pB,GAChB,QAAS9pB,GAAUtF,IAAM,WAEvBsF,EAAOtE,KAAK,KAAMa,GAAY,WAAc,OAAO,GAAM,EAC7D,GACA,ECRIuZ,GAAIhb,GAEJ+M,GAAgBlJ,GAChBmJ,GAAkBxG,GAClB+oB,GAAsBznB,GAEtB0nB,GALc9tB,GAKW,GAAG6J,MC6QzB,SAASkkB,GAAuBC,EAAUllB,EAAOwU,EAAM3V,GAC1D,GAAa,MAAT2V,IAAiB3V,EAAG,MAAM,IAAIhI,UAAU,iDAC5C,GAAqB,mBAAVmJ,EAAuBklB,IAAallB,IAAUnB,GAAKmB,EAAMb,IAAI+lB,GAAW,MAAM,IAAIruB,UAAU,4EACvG,MAAgB,MAAT2d,EAAe3V,EAAa,MAAT2V,EAAe3V,EAAEzI,KAAK8uB,GAAYrmB,EAAIA,EAAE7F,MAAQgH,EAAMrK,IAAIuvB,EACxF,CD1QA1U,GAAE,CAAE9O,OAAQ,QAAS4G,OAAO,EAAM9B,OALhBjE,KAAkB9M,SACPsvB,GAAoB,OAAQ,MAIL,CAClDhkB,KAAM,SAAcokB,GAClB,OAAOH,GAAWxiB,GAAgB1J,WAAqBR,IAAd6sB,EAA0B,IAAMA,EAC1E,IEhBH,IACInuB,GAAWE,GACXkuB,GAAa/rB,GAFT7D,GASN,CAAEkM,OAAQ,SAAU4E,MAAM,EAAME,OANtBxK,IAEoB,WAAcopB,GAAW,EAAG,KAIK,CAC/D3lB,KAAM,SAAc9I,GAClB,OAAOyuB,GAAWpuB,GAASL,GAC5B,ICZH,ICkBMgL,GDlBF7H,GAAWtE,GACX6M,GAAUnL,GAGVmuB,GAFkBhsB,GAEM,SEJxBisB,GFQa,SAAU3uB,GACzB,IAAI2uB,EACJ,OAAOxrB,GAASnD,UAAmC2B,KAA1BgtB,EAAW3uB,EAAG0uB,OAA0BC,EAA2B,WAAhBjjB,GAAQ1L,GACtF,EETIC,GAAaC,UCAbwuB,GAFkB7vB,GAEM,SFFxBgb,GAAIhb,GACJuH,GAAc7F,GACdM,GAA2B6B,GAA2DwF,EACtF8E,GAAW3H,GACXzC,GAAW+D,GACXioB,GCDa,SAAU5uB,GACzB,GAAI2uB,GAAS3uB,GACX,MAAM,IAAIC,GAAW,iDACrB,OAAOD,CACX,EDFIG,GAAyB+I,GACzB2lB,GEHa,SAAUhB,GACzB,IAAIiB,EAAS,IACb,IACE,MAAMjB,GAAaiB,EACpB,CAAC,MAAOC,GACP,IAEE,OADAD,EAAOJ,KAAS,EACT,MAAMb,GAAaiB,EAChC,CAAM,MAAOE,GAAuB,CACjC,CAAC,OAAO,CACX,EFHIC,GAAmB7oB,GAAY,GAAG8oB,YAClCjlB,GAAc7D,GAAY,GAAG8D,OAC7B0C,GAAM9K,KAAK8K,IAEXuiB,GAA0BN,GAAqB,cASnDhV,GAAE,CAAE9O,OAAQ,SAAU4G,OAAO,EAAM9B,UAPCsf,KAC9BnkB,GAAanK,GAAyBqC,OAAO1D,UAAW,eACrDwL,IAAeA,GAAW1I,aAK8B6sB,IAA2B,CAC1FD,WAAY,SAAoBE,GAC9B,IAAI7b,EAAO3Q,GAASzC,GAAuBgC,OAC3CysB,GAAWQ,GACX,IAAItiB,EAAQE,GAASJ,GAAI9M,UAAUkE,OAAS,EAAIlE,UAAU,QAAK6B,EAAW4R,EAAKvP,SAC3EqrB,EAASzsB,GAASwsB,GACtB,OAAOH,GACHA,GAAiB1b,EAAM8b,EAAQviB,GAC/B7C,GAAYsJ,EAAMzG,EAAOA,EAAQuiB,EAAOrrB,UAAYqrB,CACzD,IGjCH,IAAIC,GAAWzwB,GAAwC0R,QCAnDxO,GAASlD,GACT0uB,GAAehtB,GACf8sB,GAAwB3qB,GACxB6N,GDFsBhQ,GAEc,WAOpC,GAAGgQ,QAH2B,SAAiByZ,GACjD,OAAOsF,GAASntB,KAAM6nB,EAAYlqB,UAAUkE,OAAS,EAAIlE,UAAU,QAAK6B,EAE1E,ECNIiH,GAA8BjC,GAE9B+mB,GAAkB,SAAUC,GAE9B,GAAIA,GAAuBA,EAAoBpd,UAAYA,GAAS,IAClE3H,GAA4B+kB,EAAqB,UAAWpd,GAC7D,CAAC,MAAO5R,GACPgvB,EAAoBpd,QAAUA,EAC/B,CACH,EAEA,IAAK,IAAIqd,MAAmBL,GACtBA,GAAaK,KACfF,GAAgB3rB,GAAO6rB,KAAoB7rB,GAAO6rB,IAAiBpuB,WAIvEkuB,GAAgBL,ICrBhB,IAAI1sB,GAAc9B,GACdJ,GAAQ8B,GACR6F,GAAc1D,GACdggB,GAAuBrd,GACvByK,GAAanJ,GACbkF,GAAkBhF,GAGlB0E,GAAuBnF,GAFC8C,GAAsDhB,GAG9EnC,GAAOK,GAAY,GAAGL,MAItBwpB,GAAS5uB,IAAelC,IAAM,WAEhC,IAAI0J,EAAIrJ,OAAOkjB,OAAO,MAEtB,OADA7Z,EAAE,GAAK,GACCoD,GAAqBpD,EAAG,EAClC,IAGIgF,GAAe,SAAUqiB,GAC3B,OAAO,SAAUxvB,GAQf,IAPA,IAMIU,EANAyH,EAAI0D,GAAgB7L,GACpB8I,EAAOgH,GAAW3H,GAClBsnB,EAAgBF,IAAsC,OAA5B7M,GAAqBva,GAC/CnE,EAAS8E,EAAK9E,OACd6J,EAAI,EACJpG,EAAS,GAENzD,EAAS6J,GACdnN,EAAMoI,EAAK+E,KACNlN,MAAgB8uB,EAAgB/uB,KAAOyH,EAAIoD,GAAqBpD,EAAGzH,KACtEqF,GAAK0B,EAAQ+nB,EAAa,CAAC9uB,EAAKyH,EAAEzH,IAAQyH,EAAEzH,IAGhD,OAAO+G,CACX,CACA,ECrCIioB,GDuCa,CAGfnL,QAASpX,IAAa,GAGtBsS,OAAQtS,IAAa,IC7CgCoX,QCAhD,SAASoL,GAAQpjB,GACtB,OAAY,MAALA,IAAcqjB,OAAOC,MAAMtjB,EACpC,CAEO,SAASujB,GAAiBtsB,EAAG2M,GAClC,OAAQwf,GAAQxf,IAAMwf,GAAQnsB,IAAMusB,EAAUvsB,EAAG2M,EACnD,CAUO,SAAS6f,GAAOzjB,GACrB,OAAO0jB,SAAS1jB,GAAKA,EAAI2jB,GAC3B,CAEO,SAASC,GAAS5jB,GACvB,OAAOA,EAAI,GAAK0jB,SAAS1jB,GAAKA,EAAI2jB,GACpC,CAEO,SAASE,GAAS7jB,GACvB,OAAOA,EAAI,GAAK0jB,SAAS1jB,GAAKA,EAAI2jB,GACpC,CD3BQrxB,GAKN,CAAEkM,OAAQ,SAAU4E,MAAM,GAAQ,CAClC4U,QAAS,SAAiBpc,GACxB,OAAOunB,GAASvnB,EACjB,IETH,MAAMkoB,GAAK,6GAEI,SAASC,GAAMthB,EAAQuhB,GACpC,OAAKF,GAAGnxB,KAAK8P,GAAU,IAChB,IAAIwhB,KAAKxhB,GADuC,mBAAbuhB,EAA0BA,EAASvhB,GAAUuhB,CAEzF,CCAA,MAAME,GAAgB,IAAIC,IAAI,CAC5B,CAAC,SAAUC,GACX,CAAC,SAAUC,GACX,CAAC,OAAQC,GACT,CAAC,MAAOC,GACR,CAAC,OAAQC,GACT,CAAC,QAASC,GACV,CAAC,UAAWA,EAAUzG,MAAM,IAC5B,CAAC,OAAQyG,EAAUzG,MAAM,IACzB,CAAC,OAAQ0G,GACT,CAAC,SAAUC,GACX,CAAC,UAAWC,GACZ,CAAC,YAAaC,GACd,CAAC,WAAYC,GACb,CAAC,SAAUC,GACX,CAAC,WAAYC,GACb,CAAC,SAAUC,KAGPC,GAAe,IAAIf,IAAI,CAC3B,CAAC,SAAUgB,GACX,CAAC,SAAUC,GACX,CAAC,OAAQC,GACT,CAAC,MAAOC,GACR,CAAC,OAAQC,GACT,CAAC,QAASC,GACV,CAAC,UAAWA,EAASxH,MAAM,IAC3B,CAAC,OAAQwH,EAASxH,MAAM,IACxB,CAAC,OAAQyH,GACT,CAAC,SAAUC,GACX,CAAC,UAAWC,GACZ,CAAC,YAAaC,GACd,CAAC,WAAYC,GACb,CAAC,SAAUC,GACX,CAAC,WAAYC,GACb,CAAC,SAAUC,KAGN,SAASC,GAAkBC,GAChC,MAAM5kB,EAAI4iB,GAAczxB,IAAI,GAAGyzB,IAAWxjB,eAC1C,IAAKpB,EAAG,MAAM,IAAI6kB,MAAM,qBAAqBD,KAC7C,OAAO5kB,CACT,CAEO,SAAS8kB,GAAiBF,GAC/B,MAAM5kB,EAAI4jB,GAAazyB,IAAI,GAAGyzB,IAAWxjB,eACzC,IAAKpB,EAAG,MAAM,IAAI6kB,MAAM,qBAAqBD,KAC7C,OAAO5kB,CACT,CChDO,MAAM+kB,GAAa9zB,OAAOyjB,eAAesQ,YAC1CC,GAAiBh0B,OAAOU,UAAUoD,SA6C3BmwB,GAAYxmB,GAAM,IAAMA,EAU9B,SAASymB,GAAcvT,GAC5B,OAAOA,aAAkBmT,GAAanT,EAAS2K,GAAI3K,EAAQwT,GAAcC,aAC3E,CAKA,SAASD,GAAa1mB,GACpB,OAAY,MAALA,EAAY2jB,IAAMN,OAAOrjB,EAClC,CAEO,SAAS4mB,GAAY1T,GAC1B,OAAO2K,GAAI3K,EAAQ2T,GACrB,CAQO,SAASA,GAAW7mB,GACzB,OAAOA,aAAaikB,OAASX,MAAMtjB,GAC/BA,EACa,iBAANA,EACP8mB,GAAS9mB,GACJ,MAALA,GAAasjB,MAAOtjB,GAAKA,QACzB5K,EACA,IAAI6uB,KAAKjkB,EACf,CAiCO,SAAS+mB,GAAS1kB,GACvB,OAAe,MAARA,GAAgBA,aAAgB8C,OAAS9C,aAAgBgkB,GAAahkB,EAAO8C,MAAMwN,KAAKtQ,EACjG,CAIO,SAASwb,GAAI3K,EAAQvX,EAAG2B,EAAO6H,OACpC,OAAiB,MAAV+N,EAAiBA,EAASA,aAAkB5V,EAAO4V,EAAO2K,IAAIliB,GAAK2B,EAAKqV,KAAKO,EAAQvX,EAC9F,CAIO,SAASgC,GAAMuV,EAAQ5V,EAAO6H,OACnC,OAAO+N,aAAkB5V,EAAO4V,EAAOvV,QAAUL,EAAKqV,KAAKO,EAC7D,CAYO,SAAS8T,GAAeC,GAC7B,OAVK,SAAkBA,GACvB,OAAOA,GAAQ5wB,WAAakwB,EAC9B,CAQS3vB,CAASqwB,UAA4B7xB,IAAhB6xB,EAAO3pB,WAAwClI,IAAlB6xB,EAAO/b,OAClE,CA2HO,SAASgc,GAAchB,EAAU5oB,GACtC,GAAgB,MAAZ4oB,EAAJ,CACA,GAAwB,iBAAbA,EAAuB,CAC5B,EAAIA,GAAYA,EAAW,GAAK7C,OAAO8D,UAAU,EAAIjB,KAAWA,GAAY,EAAIA,GACpF,MAAMjmB,EAAI1K,KAAK6xB,IAAIlB,GACnB,OAAOA,EAAW,EACd,CACEpmB,MAAQunB,GAAM9xB,KAAKuK,MAAMunB,EAAIpnB,GAAKA,EAClCqnB,OAASD,IAAOA,EAAIpnB,EAAI,GAAKA,EAC7BsnB,MAAO,CAACC,EAAIC,IAAOC,EAAOnyB,KAAKsK,KAAK2nB,EAAKvnB,GAAIwnB,EAAKxnB,GAAG4d,KAAK7d,GAAMA,EAAIC,KAEtE,CACEH,MAAQunB,GAAM9xB,KAAKuK,MAAMunB,EAAIpnB,GAAKA,EAClCqnB,OAASD,GAAMA,EAAIpnB,EACnBsnB,MAAO,CAACC,EAAIC,IAAOC,EAAOnyB,KAAKsK,KAAK2nB,EAAKvnB,GAAIwnB,EAAKxnB,GAAG4d,KAAK7d,GAAMA,EAAIC,IAE3E,CACD,GAAwB,iBAAbimB,EAAuB,OAAiB,SAAT5oB,EAAkB2oB,GAAoBG,IAAkBF,GAClG,GAA8B,mBAAnBA,EAASpmB,MAAsB,MAAM,IAAIqmB,MAAM,0CAC1D,GAA+B,mBAApBD,EAASoB,OAAuB,MAAM,IAAInB,MAAM,2CAC3D,OAAOD,CAnBsB,CAoB/B,CAGO,SAASyB,GAAmBzB,EAAU5oB,GAE3C,IADA4oB,EAAWgB,GAAchB,EAAU5oB,KACO,mBAAnB4oB,EAASqB,MAAsB,MAAM,IAAIpB,MAAM,0CACtE,OAAOD,CACT,CA6CO,SAAS0B,GAAU1U,GACxB,IAAK,MAAMpd,KAASod,EAAQ,CAC1B,GAAa,MAATpd,EAAe,SACnB,MAAMwH,SAAcxH,EACpB,MAAgB,WAATwH,GAA8B,YAATA,CAC7B,CACH,CAEO,SAASuqB,GAAW3U,GACzB,IAAK,MAAMpd,KAASod,EAClB,GAAa,MAATpd,EACJ,OAAOA,aAAiBmuB,IAE5B,CAMO,SAAS6D,GAAiB5U,GAC/B,IAAK,MAAMpd,KAASod,EAClB,GAAa,MAATpd,EACJ,MAAwB,iBAAVA,GAAsBwtB,MAAMxtB,IAAUgxB,GAAShxB,EAEjE,CAIO,SAASiyB,GAAgB7U,GAC9B,IAAK,MAAMpd,KAASod,EAClB,GAAa,MAATpd,EAAJ,CACA,GAAqB,iBAAVA,EAAoB,OAAO,EACtC,GAAKA,EAAMkyB,OACX,OAAQ1E,MAAMxtB,EAHc,CAKhC,CAyEO,SAASmyB,GAAQ/U,GACtB,GAAc,MAAVA,EAAgB,OACpB,MAAMyF,EAAQzF,EAAO,GACfgV,EAAOhV,EAAOA,EAAOzb,OAAS,GACpC,OAAO0wB,EAAWxP,EAAOuP,EAC3B,CC1cO,MAAMrP,GAAWpgB,OAAO,YAKlB2vB,GAAQ3vB,OAAO,SAIf4vB,GAAS5vB,OAAO,UAIhBhB,GAASgB,OAAO,UAIhB6vB,GAAU7vB,OAAO,WAGjBD,GAASC,OAAO,UAKhB8vB,GAAW,IAAIpE,IAAI,CAC9B,CAAC,IAAKtL,IACN,CAAC,IAAKA,IACN,CAAC,KAAMA,IACP,CAAC,KAAMA,IACP,CAAC,IAAKwP,IACN,CAAC,QAASD,IACV,CAAC,UAAWE,IACZ,CAAC,SAAU9vB,IACX,CAAC,SAAUf,MChCA+wB,GAAU,EADFjzB,KAAKkzB,KAAK,GAkBzBC,GAAU,IAAIvE,IAAI,CACtB,CAAC,WAAYwE,GACb,CAAC,SAAUC,GACX,CAAC,QAASC,GACV,CAAC,UAAWC,GACZ,CAAC,WAAYC,GACb,CAAC,UArBmB,CACpBC,KAAKC,EAASnQ,GACZ,MAAMoQ,EAAK3zB,KAAKkzB,KAAK3P,EAAOvjB,KAAK4zB,IAC/BC,EAAKF,EAAKV,GACVa,EAAKD,EAAK,EACZH,EAAQK,OAAO,EAAGF,GAClBH,EAAQM,OAAOL,EAAIG,GACnBJ,EAAQM,OAAOL,GAAKG,GACpBJ,EAAQM,OAAO,GAAIH,GACnBH,EAAQM,QAAQL,GAAKG,GACrBJ,EAAQM,QAAQL,EAAIG,GACpBJ,EAAQO,WACT,IAUD,CAAC,OAAQC,GACT,CAAC,SAAUC,GACX,CAAC,UAAWC,GACZ,CAAC,OAAQC,GACT,CAAC,QAASC,GACV,CAAC,WAAYC,GACb,CAAC,YAAaC,GACd,CAAC,MAAOC,KAaH,SAASC,GAAYzxB,GAC1B,GAAc,MAAVA,GAXN,SAAwB1C,GACtB,OAAOA,GAA+B,mBAAfA,EAAMkzB,IAC/B,CASwBkB,CAAe1xB,GAAS,OAAOA,EACrD,MAAM1C,EAAQ4yB,GAAQj2B,IAAI,GAAG+F,IAASkK,eACtC,GAAI5M,EAAO,OAAOA,EAClB,MAAM,IAAIqwB,MAAM,mBAAmB3tB,IACrC,CC7CO,SAAS2xB,GAAKC,GACnBvc,QAAQsc,KAAKC,EAEf,CCoEA,MAAMC,GAAiB,IAAIlG,IAAI,CAE7B,CAAC,SAAUmG,GACX,CAAC,aAAcC,GACf,CAAC,QAASC,GACV,CAAC,SAAUC,GACX,CAAC,UAAWC,GACZ,CAAC,UAAWC,GACZ,CAAC,OAAQC,GACT,CAAC,OAAQC,GACT,CAAC,OAAQC,IACT,CAAC,YAAaC,IAGd,CAAC,OAAQC,GAASC,GAAYC,KAC9B,CAAC,OAAQF,GAASG,GAAYC,KAC9B,CAAC,OAAQJ,GAASK,GAAYC,KAC9B,CAAC,OAAQN,GAASO,GAAYC,KAC9B,CAAC,OAAQR,GAASS,GAAYC,KAC9B,CAAC,OAAQV,GAASW,GAAYC,KAC9B,CAAC,SAAUZ,GAASa,GAAcC,KAClC,CAAC,SAAUd,GAASe,GAAcC,KAClC,CAAC,WAAYhB,GAASiB,GAAgBC,KAGtC,CAAC,OAAQC,GAAUV,GAAYC,KAC/B,CAAC,SAAUS,GAAUN,GAAcC,KAGnC,CAAC,QAASM,GAAQC,GAAaC,KAC/B,CAAC,SAAUF,GAAQG,GAAcC,KACjC,CAAC,QAASJ,GAAQK,GAAaC,KAC/B,CAAC,UAAWN,GAAQO,GAAeC,KACnC,CAAC,UAAWR,GAAQS,GAAeC,KACnC,CAAC,OAAQV,GAAQW,GAAYC,KAG7B,CAAC,QAASC,GAAQC,KAClB,CAAC,UAAWD,GAAQE,KACpB,CAAC,QAASF,GAAQG,KAClB,CAAC,UAAWH,GAAQI,KACpB,CAAC,SAAUJ,GAAQK,KACnB,CAAC,UAAWL,GAAQM,KACpB,CAAC,YAAaN,GAAQO,KACtB,CAAC,OAAQP,GAAQQ,KACjB,CAAC,OAAQR,GAAQS,KACjB,CAAC,OAAQtB,GAAQuB,GAAYC,KAC7B,CAAC,OAAQxB,GAAQyB,GAAYC,KAC7B,CAAC,OAAQ1B,GAAQ2B,GAAYC,KAC7B,CAAC,OAAQ5B,GAAQ6B,GAAYC,KAC7B,CAAC,OAAQ9B,GAAQ+B,GAAYC,KAC7B,CAAC,SAAUhC,GAAQiC,GAAcC,KACjC,CAAC,OAAQlC,GAAQmC,GAAYC,KAC7B,CAAC,OAAQpC,GAAQqC,GAAYC,KAC7B,CAAC,OAAQtC,GAAQuC,GAAYC,KAC7B,CAAC,SAAUxC,GAAQyC,GAAcC,KACjC,CAAC,SAAU1C,GAAQ2C,GAAcC,KACjC,CAAC,SAAU5C,GAAQ6C,GAAcC,KAGjC,CAAC,UAAWC,GAAgBC,KAC5B,CAAC,UAAWD,GAAgBE,OAG9B,SAASjD,GAAQkD,EAAQC,GACvB,MAAO,EAAE93B,OAAQwI,KACL,IAANA,EAAgB,CAACqvB,EAAO,GAAG,IACrB,IAANrvB,EAAgB,CAACqvB,EAAO,GAAG,GAAIA,EAAO,GAAG,KAC7CrvB,EAAI1K,KAAK6K,IAAI,EAAG7K,KAAKuK,MAAMG,KAChB,EAAIuvB,GAASD,EAAatvB,GAAKqvB,EAAOrvB,EAErD,CAEA,SAAS+qB,GAASsE,EAAQC,GACxB,MAAO,EAAE93B,OAAQwI,KACL,IAANA,EAAgB,CAACqvB,EAAO,GAAG,GAAIA,EAAO,GAAG,KAC7CrvB,EAAI1K,KAAK6K,IAAI,EAAG7K,KAAKuK,MAAMG,KAChB,GAAKuvB,GAASD,EAAatvB,GAAKqvB,EAAOrvB,EAEtD,CAEA,SAASksB,GAAUmD,EAAQC,GACzB,MAAO,EAAE93B,OAAQwI,KACL,IAANA,EAAgB,CAACqvB,EAAO,GAAG,GAAIA,EAAO,GAAG,KAC7CrvB,EAAI1K,KAAK6K,IAAI,EAAG7K,KAAKuK,MAAMG,KAChB,GAAKuvB,IAAUC,GAAMF,EAAY,EAAIE,IAAIxvB,GAAKqvB,EAAOrvB,GAAGtC,QAAQ+xB,SAE/E,CAEA,SAASzC,GAAQsC,GACf,MAAO,EAAE93B,OAAQwI,KAAOuvB,GAASD,EAAah6B,KAAK6K,IAAI,EAAG7K,KAAKuK,MAAMG,IACvE,CAEA,SAASkvB,GAAgBI,GACvB,MAAO,EAAE93B,OAAQwI,KAAOuvB,GAASD,EAAah6B,KAAKuK,MAAMG,GAAK,GAAGtC,MAAM,GAAI,EAC7E,CAEO,SAASgyB,GAAcL,GAC5B,MAAMM,EAAI,GAAGN,IAAS5sB,cACtB,IAAK2nB,GAAepuB,IAAI2zB,GAAI,MAAM,IAAIzJ,MAAM,2BAA2ByJ,KACvE,OAAOvF,GAAe53B,IAAIm9B,EAC5B,CAEO,SAASC,GAAaP,EAAQ73B,GACnC,MAAMm4B,EAAID,GAAcL,GAClB9b,EAAiB,mBAANoc,EAAmBA,EAAE,CAACn4B,WAAWm4B,EAClD,OAAOpc,EAAE/b,SAAWA,EAAS+b,EAAE7V,MAAM,EAAGlG,GAAU+b,CACpD,CAiBA,MAAMsc,GAAsB,IAAI3L,IAAI,CAElC,CAAC,OAAQ+G,IACT,CAAC,OAAQE,IACT,CAAC,OAAQE,IACT,CAAC,OAAQE,IACT,CAAC,OAAQE,IACT,CAAC,OAAQE,IACT,CAAC,SAAUE,IACX,CAAC,SAAUE,IACX,CAAC,WAAYE,IAGb,CAAC,OAASuD,GAAM/D,GAAgB,EAAI+D,IACpC,CAAC,SAAWA,GAAM3D,GAAkB,EAAI2D,IAGxC,CAAC,QAASnD,IACV,CAAC,SAAUE,IACX,CAAC,QAASE,IACV,CAAC,UAAWI,IACZ,CAAC,OAAQE,IACT,CAAC,UAAWJ,IAGZ,CAAC,QAASM,IACV,CAAC,UAAWC,IACZ,CAAC,QAASC,IACV,CAAC,UAAWC,IACZ,CAAC,SAAUC,IACX,CAAC,UAAWC,IACZ,CAAC,YAAaC,IACd,CAAC,OAAQC,IACT,CAAC,OAAQC,IACT,CAAC,OAAQE,IACT,CAAC,OAAQE,IACT,CAAC,OAAQE,IACT,CAAC,OAAQE,IACT,CAAC,SAAUI,IACX,CAAC,OAAQF,IACT,CAAC,OAAQI,IACT,CAAC,OAAQE,IACT,CAAC,SAAUI,IACX,CAAC,OAAQF,IACT,CAAC,SAAUI,IACX,CAAC,SAAUE,IAGX,CAAC,UAAWE,IACZ,CAAC,UAAWC,MAGP,SAASU,GAAmBT,GACjC,MAAMM,EAAI,GAAGN,IAAS5sB,cACtB,IAAKotB,GAAoB7zB,IAAI2zB,GAAI,MAAM,IAAIzJ,MAAM,gCAAgCyJ,KACjF,OAAOE,GAAoBr9B,IAAIm9B,EACjC,CAEA,MAAMI,GAAmB,IAAIC,IAAI,CAC/B,OACA,OACA,OACA,OACA,OACA,OACA,SACA,SACA,WACA,OACA,WAGK,SAASC,GAAkBZ,GAChC,OAAiB,MAAVA,GAAkBU,GAAiB/zB,IAAI,GAAGqzB,IAAS5sB,cAC5D,CCxPO,MAAMytB,GAAQ7uB,GAAOmuB,GAAMnuB,EAAE,EAAImuB,GAClCW,GAAO,CAAC,EAAG,GAEXC,GAAgB,IAAIlM,IAAI,CAE5B,CAAC,SAAUmM,IAGX,CAAC,MAAOC,IACR,CAAC,MAAOC,IACR,CAAC,MAAOC,IACR,CAAC,MAAOC,MAGH,SAASC,GAAkBpB,GAChC,MAAMjuB,EAAI,GAAGiuB,IAAc7sB,cAC3B,IAAK2tB,GAAcp0B,IAAIqF,GAAI,MAAM,IAAI6kB,MAAM,yBAAyB7kB,KACpE,OAAO+uB,GAAc59B,IAAI6O,EAC3B,CAEO,SAASsvB,GACdz8B,EACA08B,EACAC,GACAxzB,KACEA,EAAIyzB,KACJA,EAAIC,MACJA,EAAKC,KACLA,EAAI/lB,OACJA,EAASgmB,GAAgB/8B,EAAK28B,GAASK,QACvCA,EAAOC,MACPA,EAAK9B,OACLA,EAAMpJ,SACNA,EAAQqB,MACRA,GAAQgB,GAAS91B,IAAI0B,KAASk0B,GAC1BgJ,GAAiBP,EAAU5lB,GAC3Bqd,GAAS91B,IAAI0B,KAASsD,GACtB65B,GAAiBR,EAAU5lB,GAC3Bqd,GAAS91B,IAAI0B,KAASm0B,GACtB8H,QACAh7B,GAASm6B,YACbA,GAAchH,GAAS91B,IAAI0B,KAASi0B,GACtB,MAAVkH,QAA4Bl6B,IAAVmyB,EAChBgJ,GACAR,QAA8B36B,IAAXk6B,EAAuBA,EAAkB,aAAThyB,EAAsB,UAAY,SACvF8zB,EACAG,GACAjB,IACRZ,QAAIA,IAkCF,GA/BAxJ,EAAWyB,GAAmBzB,EAAU5oB,GAC3B,aAATA,GAAgC,eAATA,IAAuBA,EAAO,UACzDoyB,IAAYA,EAOe,mBAAhBH,IACTA,EAAcoB,GAAkBpB,IAEP,IAAvBA,EAAY93B,QACVi4B,IACFH,EAAcY,GAAKZ,GACnBG,GAAU,QAEEt6B,IAAVmyB,GAEmB,KADrBA,EAAQZ,aAAahU,KAAKzH,GAAQ,CAACsmB,EAAGlwB,IAAMA,GAAK4J,EAAOzT,OAAS,MACvDA,SAAc8vB,EAAQ6I,IAElCS,EAAMtB,aAAahI,IAAU6I,GAAO5J,GAAWiL,IAAsBlC,KAErEsB,EAAMtB,YAAYA,GAQhB0B,EAAM,CACR,MAAO5wB,EAAKD,GAAOsxB,GAAOxmB,IACtB7K,EAAM,GAAKD,EAAM,KAEf6nB,GADJ/c,EAASvN,GAAMuN,MACS3V,KAAKo8B,KAAKtxB,GAAM6K,EAAOA,EAAOzT,OAAS,GAAK,EAE/DyT,EAAO,GAAK,EAEpB,CAOD,OALIwkB,IAASxkB,EAAS0mB,GAAU1mB,IAChC2lB,EAAM3lB,OAAOA,GAAQimB,QAAQA,GACzBJ,IAAMF,EAAME,KAMlB,SAAmBA,EAAMzzB,GACvB,OAAgB,IAATyzB,OAAgB37B,EAA4B,iBAAT27B,EAAoBA,EL+KzD,SAA2B7K,EAAU5oB,GAE1C,IADA4oB,EAAWyB,GAAmBzB,EAAU5oB,KACC,mBAAlB4oB,EAASrmB,KAAqB,MAAM,IAAIsmB,MAAM,yCACrE,OAAOD,CACT,CKnLuE2L,CAAkBd,EAAMzzB,EAC/F,CARuBw0B,CAAUf,EAAMzzB,IAAS4N,EAAS2lB,EAAM3lB,eAC/C9V,IAAVmyB,GAAqBsJ,EAAMtJ,MAAMA,GACjCyJ,GAAOH,EAAMG,MAAMA,GAChB,CAAC1zB,OAAM4N,SAAQqc,QAAOsJ,QAAOtB,cAAarJ,WACnD,CAcO,SAAS6L,GAAe59B,EAAK28B,GAAUkB,SAACA,EAAW,KAAM9zB,IAC9D,OAAO0yB,GAAaz8B,EAAK89B,KAAWD,SAASA,GAAWlB,EAAU,IAAI5yB,EAASZ,KAAM,OACvF,CAwEO,SAAS40B,GACd/9B,EACA28B,GACA5lB,OACEA,EAAS,CAAC,GAAEimB,QACZA,EAAO7B,OACPA,EAAS,SAAQC,YACjBA,EAAWhI,MACXA,QAAwBnyB,IAAhBm6B,EACJC,GAASD,EAAarkB,EAAOzT,OAAS,GACtC8wB,GAAS91B,IAAI0B,KAASi0B,GACtByH,GAAaP,EAAQpkB,EAAOzT,OAAS,QACrCrC,GACRs6B,QAAIA,IAIF,MAAMiC,EAAO1J,GADb/c,EAAS6b,GAAS7b,IAElB,IAAKoY,MAAMqO,KAUb,SAAmBzmB,EAAQymB,GACzB,IAAK,IAAIrwB,EAAI,EAAGrB,EAAIiL,EAAOzT,OAAQ4vB,EAAInc,EAAO,GAAI5J,EAAIrB,IAAKqB,EAAG,CAC5D,MAAMsuB,EAAIzH,EAAWd,EAAIA,EAAInc,EAAO5J,IACpC,GAAU,IAANsuB,GAAWA,IAAM+B,EAAM,OAAO,CACnC,CACD,OAAO,CACT,CAhBuBQ,CAAUjnB,EAAQymB,GAAO,MAAM,IAAIxL,MAAM,OAAOhyB,sCAErE,OADIu7B,IAASnI,EAAQqK,GAAUrK,IACxB,CACLjqB,KAAM,YACNuzB,MAAOuB,GAAeT,EAAO,EAAIC,GAAU1mB,GAAUA,OAAkB9V,IAAVmyB,EAAsB,GAAKA,GAAO4J,QAAQA,GACvGjmB,SACAqc,QAEJ,CAcO,SAAS8K,GAAYvB,EAAUn1B,EAAI8nB,IACxC,OAAOqN,EAASr5B,OACZ,CACE4I,GAAIywB,GAAU,EAAEh7B,gBAAsBV,IAAVU,EAAsBA,EAAQuK,GAAIvK,EAAO6F,KACrEyE,GAAI0wB,GAAU,EAAEh7B,gBAAsBV,IAAVU,EAAsBA,EAAQsK,GAAItK,EAAO6F,MAEvE,CAAC,EAAG,EACV,CAEA,SAASu1B,GAAgB/8B,EAAK28B,GAC5B,MAAMxzB,EAAOirB,GAAS91B,IAAI0B,GAC1B,OAAQmJ,IAAS+qB,IAAU/qB,IAASgrB,IAAWhrB,IAAS7F,GAAS66B,GAAkBD,IAAavB,EAClG,CAEA,SAASwB,GAAgBxB,GACvB,MAAO,CAAC,EAAGA,EAASr5B,OAAS2I,GAAI0wB,GAAU,EAAEh7B,gBAAsBV,IAAVU,EAAsBA,EAAQsK,GAAItK,EAAO2tB,MAAY,EAChH,CAKA,SAAS4N,GAAiBP,EAAU5lB,GAClC,MAAMqnB,EAAOzB,EAAS7S,MAAK,EAAEoK,iBAAuBjzB,IAAXizB,IACzC,QAAajzB,IAATm9B,EAAoB,MAAO,CAAC,EAAGA,EAAKlK,QACxC,MAAMmK,EAAMC,GAAS3B,EAAU,IAAK,EAAEh7B,gBAAsBV,IAAVU,EAAsB6tB,IAAM8O,GAAS38B,EAAO,IAAM8tB,MAC9F2D,EAAQrc,EAAO2S,KAAKwJ,GAAM,EAAI9xB,KAAKkzB,KAAKpB,EAAImL,KAC5C9Y,EAAI,GAAKtZ,GAAImnB,GACnB,OAAO7N,EAAI,EAAI6N,EAAM1J,KAAKrK,GAAMA,EAAIkG,IAAK6N,CAC3C,CAKA,SAAS+J,GAAiBR,EAAU5lB,GAClC,MAAMwnB,EAAMC,GAAO7B,GAAU,EAAEh7B,gBAAsBV,IAAVU,EAAsB6tB,IAAMgP,GAAO78B,EAAOP,KAAK6xB,OACpFG,EAAQrc,EAAO2S,KAAKwJ,GAAO,GAAKA,EAAKqL,IACrChZ,EAAI,GAAKtZ,GAAImnB,GACnB,OAAO7N,EAAI,EAAI6N,EAAM1J,KAAKrK,GAAMA,EAAIkG,IAAK6N,CAC3C,CAEA,SAASqL,GAAe9B,GACtB,IAAK,MAAMh7B,MAACA,KAAUg7B,EACpB,QAAc17B,IAAVU,EACF,IAAK,IAAI+8B,KAAK/8B,EAAO,CACnB,GAAI+8B,EAAI,EAAG,OAAOR,GAAYvB,EAAUlN,IACxC,GAAIiP,EAAI,EAAG,OAAOR,GAAYvB,EAAUjN,GACzC,CAGL,MAAO,CAAC,EAAG,GACb,CAEA,SAASiP,GAAoBhC,GAC3B,MAAM5lB,EAAS,GACf,IAAK,MAAMpV,MAACA,KAAUg7B,EACpB,QAAc17B,IAAVU,EACJ,IAAK,MAAM+8B,KAAK/8B,EAAOoV,EAAO1R,KAAKq5B,GAErC,OAAO3nB,CACT,CAEO,SAASumB,GAAqBlC,GACnC,MAAO,CAACjuB,EAAG+C,IAAOorB,GAAMF,EAAYjuB,EAAImuB,GAAKprB,EAAI/C,GACnD,CC/SA,SAASyxB,GACP5+B,EACA08B,EACAmC,EACAlC,GACAxzB,KACEA,EAAIyzB,KACJA,EAAIC,MACJA,EAAK9lB,OACLA,EAASmnB,GAAYvB,GAASK,QAC9BA,EAAO8B,MACPA,EAAQ,EAAC3D,OACTA,EAAM/H,MACNA,EAAK2L,UACLA,GAAY,EAAI3D,YAChBA,GAAchH,GAAS91B,IAAI0B,KAASi0B,GACtB,MAAVkH,QAA4Bl6B,IAAVmyB,EAChBgJ,GACAR,QAA8B36B,IAAXk6B,EAAuBA,EAAS,QACrDgB,IAAiBZ,QACrBA,IAGFuD,GAASA,EACT,IAAK5yB,EAAKD,GAAO8K,EAwBjB,GAvBIid,EAAW9nB,EAAKD,GAAO,KAAKC,EAAKD,GAAO,CAACA,EAAKC,GAAQqvB,GAAWA,GACrErvB,EAAM9K,KAAK8K,IAAIA,EAAK4yB,GACpB7yB,EAAM7K,KAAK6K,IAAIA,EAAK6yB,GAOO,mBAAhB1D,IACTA,EAAcoB,GAAkBpB,SAIpBn6B,IAAVmyB,IACFgI,EACyB,IAAvBA,EAAY93B,OAAeg6B,GAAqBlC,EAArBkC,IAAqClK,GAAS4L,GAAU5D,EAAahI,IAIhGmI,IAASH,EAAcY,GAAKZ,IAG5B2D,EAAW,CACb,MAAME,EAAMJ,EAAU1/B,MAAM2/B,GACtBI,EAAWD,EAAMJ,EAAU1/B,MAAM+M,GACjCizB,EAAWN,EAAU1/B,MAAM8M,GAAOgzB,EACpCC,EAAWC,EAAUjzB,EAAM2yB,EAAUO,OAAOH,EAAME,GAC7CD,EAAWC,IAAUlzB,EAAM4yB,EAAUO,OAAOH,EAAMC,GAC5D,CAKD,OAHAxC,EAAM3lB,OAAO,CAAC7K,EAAK4yB,EAAO7yB,IAAM+wB,QAAQA,GAASqC,aAAajE,GAC1DyB,GAAOH,EAAMG,MAAMA,GACnBD,GAAMF,EAAME,KAAKA,GACd,CAACzzB,OAAM4N,OAAQ,CAAC7K,EAAKD,GAAM6yB,QAAO1D,cAAasB,QACxD,CAUO,SAAS4C,GAAwBt/B,EAAK28B,GAAUkB,SAACA,EAAW,KAAM9zB,IACvE,OAAO60B,GAAa5+B,EAAKu/B,KAAoB1B,SAAUA,GAAYA,GAmDrE,SAAsBA,GACpB,MAAoB,KAAbA,EACH2B,GACA,CACErgC,MAAM0M,GACGzK,KAAKo8B,KAAK3xB,GAAKzK,KAAKq+B,IAAIr+B,KAAK6xB,IAAIpnB,GAAIgyB,GAE9CuB,OAAOvzB,GACEzK,KAAKo8B,KAAK3xB,GAAKzK,KAAKq+B,IAAIr+B,KAAK6xB,IAAIpnB,GAAI,EAAIgyB,GAG1D,CA9DiF6B,CAAa7B,GAAWlB,EAAU,IAC5G5yB,EACHZ,KAAM,iBAEV,CAcO,SAASw2B,GAA2B3/B,EAAK28B,GAAUtK,SAACA,EAAW,KAAMtoB,IAC1E,OAAO60B,GACL5+B,EACA4/B,KAAuBvN,SAAUA,GAAYA,GA2CjD,SAAyBA,GACvB,MAAO,CACLlzB,MAAM0M,GACGzK,KAAKo8B,KAAK3xB,GAAKzK,KAAKy+B,MAAMz+B,KAAK6xB,IAAIpnB,EAAIwmB,IAEhD+M,OAAOvzB,GACEzK,KAAKo8B,KAAK3xB,GAAKzK,KAAK0+B,MAAM1+B,KAAK6xB,IAAIpnB,IAAMwmB,EAGtD,CAnDI0N,CAAgB1N,GAChBsK,EACA5yB,EAEJ,CAEA,MAAMi2B,GAAoB,CACxB7gC,MAAM0M,GACGA,EAETuzB,OAAOvzB,GACEA,GAILo0B,GAAe,CACnB9gC,MAAOiC,KAAK8+B,IACZd,OAAQh+B,KAAK++B,KAGTX,GAAgB,CACpBrgC,MAAM0M,GACGzK,KAAKo8B,KAAK3xB,GAAKzK,KAAKkzB,KAAKlzB,KAAK6xB,IAAIpnB,IAE3CuzB,OAAOvzB,GACEzK,KAAKo8B,KAAK3xB,IAAMA,EAAIA,IClI/B,SAASu0B,GAAapgC,EAAK08B,EAAOC,EAAU5yB,GAC1C,OAAO0yB,GAAaz8B,EAAK08B,EAAOC,EAAU5yB,EAC5C,CCOO,MAAMs2B,GAAkB/7B,OAAO,WAEtC,SAASg8B,GAAatgC,EAAK08B,EAAOC,GAAUxzB,KAACA,EAAI4oB,SAAEA,EAAQhb,OAAEA,EAAMqc,MAAEA,UAAOmI,EAAO6C,KAAEA,IAWnF,OAVArM,EAAWyB,GAAmBzB,EAAU5oB,QACzBlI,IAAX8V,IAAsBA,EAASmnB,GAAYvB,EAAU5K,EAAU/xB,IACtD,gBAATmJ,GAA0BA,IAASk3B,KAAiBl3B,EAAO,WAC3DoyB,IAASxkB,EAAS0mB,GAAU1mB,IAChC2lB,EAAM3lB,OAAOA,QACC9V,IAAVmyB,IAEmB,mBAAVA,IAAsBA,EAAQA,EAAMrc,IAC/C2lB,EAAMtJ,MAAMA,IAEP,CAACjqB,OAAM4N,SAAQqc,QAAOsJ,QAAO0B,OAAMrM,WAC5C,CAEO,SAASwO,GAAmBvgC,EAAK28B,GAAUxzB,KAACA,EAAI4oB,SAAEA,EAAQhb,OAAEA,EAAMqc,MAAEA,EAAK+H,OAAEA,EAAM6B,QAAEA,KAAYjzB,IAGpG,IAAIq0B,EACJ,GAHArM,EAAWyB,GAAmBzB,EAAU5oB,QACzBlI,IAAX8V,IAAsBA,EAASmnB,GAAYvB,EAAU5K,EAAU/xB,IAE/Do0B,GAAS91B,IAAI0B,KAASqE,GACxB+5B,EAwFJ,SAAyBzB,GACvB,MAAO,CACL6D,KAAMC,GAAU9D,EAAU,QAC1B+D,OAAQD,GAAU9D,EAAU,UAEhC,CA7FWgE,CAAgBhE,GACvBvJ,OAAkBnyB,IAAVmyB,EA8FZ,SAA0BgL,GACxB,ORySwBz8B,EQzSPy8B,EAAKoC,KR0SN,MAAT7+B,GAGF,SAAgBA,GACrB,MAAO,gBAAgBnD,KAAKmD,EAC9B,CAL0Bi/B,CAAOj/B,GQ1SDk/B,GAAgBC,GRySzC,IAAmBn/B,CQxS1B,CAhGkCo/B,CAAiB3C,GAAQ1U,GAAI0J,EAAO0C,SAC7D,GAAI1B,GAAS91B,IAAI0B,KAASi0B,UACjBhzB,IAAVmyB,GAAiC,YAATjqB,GAAsBA,IAASk3B,KACzDjN,EJ0JC,SAA2Brc,EAAQokB,EAAS,SACjD,MAAM/H,EAAQ,IAAI0I,KACXt0B,EAAG8zB,GAAKI,GAAaP,EAAQ,GACpC,IAAK,MAAMx5B,KAASoV,EAClB,GAAa,MAATpV,EACJ,IAAc,IAAVA,EAAgByxB,EAAM3d,IAAI6lB,OACzB,KAAc,IAAV35B,EACJ,OADqByxB,EAAM3d,IAAIjO,EACxB,CAEd,MAAO,IAAI4rB,EACb,CIpKc4N,CAAkBjqB,EAAQokB,QACpBl6B,IAAVmyB,IAAqB+H,OAASl6B,SAErBA,IAAXk6B,QAAkCl6B,IAAVmyB,IAC1B+H,EAAkB,YAAThyB,EAAqB,QAAU,kBAE3BlI,IAAXk6B,GACF,QAAcl6B,IAAVmyB,EAAqB,CACvB,MAAMgI,EAAcQ,GAAmBT,GACjC8F,EAAK7N,EAAM,GACfF,EAAIE,EAAM,GAAKA,EAAM,GACvBA,EAAQ,EAAE9vB,OAAQwI,KAAOuvB,IAAUC,GAAMF,EAAY6F,EAAK/N,EAAIoI,IAAIxvB,EAC1E,MACQsnB,EAAQoI,GAAcL,GAI5B,GAAI6B,IAAYkE,GACd,MAAM,IAAIlP,MAAM,uBAAuBhyB,4BAEzC,OAAOsgC,GAAatgC,EAAKmhC,KAAenE,QAAQA,GAAUL,EAAU,IAAI5yB,EAASZ,OAAM4N,SAAQqc,QAAOgL,QACxG,CAyBA,SAASgD,GAAW1E,EAAOC,EAAU5yB,EAAS/J,GAC5C,IAAIi9B,MAACA,GAASlzB,EAId,YAHc9I,IAAVg8B,GAAqBP,EAAMO,MAAOA,IAAUA,IAChDP,EAAQ4D,GAAatgC,EAAK08B,EAAOC,EAAU5yB,IACrCkzB,MAAQA,EACPP,CACT,CAEA,SAASwB,GAAYvB,EAAU5K,EAAU/xB,GACvC,MAAM+e,EAAS,IAAIsiB,GACnB,IAAK,MAAM1/B,MAACA,EAAKoV,OAAEA,KAAW4lB,EAAU,CACtC,QAAe17B,IAAX8V,EAAsB,OAAOA,IACjC,QAAc9V,IAAVU,EACJ,IAAK,MAAM+8B,KAAK/8B,EAAOod,EAAOtJ,IAAIipB,EACnC,CACD,QAAiBz9B,IAAb8wB,EAAwB,CAC1B,MAAO7lB,EAAKD,GAAOsxB,GAAOxe,GAAQ2K,IAAIqI,EAASpmB,MAAOomB,GACtD,OAAOA,EAASqB,MAAMlnB,EAAK6lB,EAASoB,OAAOlnB,GAC5C,CACD,GAAI8S,EAAO4F,KAAO,KAAQyP,GAAS91B,IAAI0B,KAAS0kB,GAC9C,MAAM,IAAIsN,MAAM,8BAA8BhyB,uCAEhD,OAAOshC,GAAKviB,EAAQqQ,GACtB,CAGA,SAASqR,GAAU9D,EAAU38B,GAC3B,IAAI2B,EACJ,IAAK,MAAMy8B,KAACA,KAASzB,EAAU,CAC7B,MAAM4E,EAAYnD,IAAOp+B,GACzB,QAAkBiB,IAAdsgC,EACJ,QAActgC,IAAVU,EAAqBA,EAAQ4/B,OAE5B,GAAI5/B,IAAU4/B,EAAW,MAC/B,CACD,OAAO5/B,CACT,CCuHO,SAAS6/B,GAAexhC,EAAK08B,EAAO0B,GACzC,OAGF,SAAqBp+B,EAAK28B,EAAW,GAAI5yB,EAAU,CAAA,GACjD,MAAMZ,EAyIR,SAAwBnJ,EAAK28B,GAAUxzB,KAACA,EAAI4N,OAAEA,EAAMqc,MAAEA,EAAK+H,OAAEA,EAAM2D,MAAEA,EAAK2C,WAAEA,IAE1E,GAAY,OAARzhC,GAAwB,OAARA,EAAc,MAAO,OAK5B,MAARA,GAAuB,MAARA,GAA8B,MAAdyhC,IAAoBt4B,EAAOu4B,IAK/D,IAAK,MAAOv4B,KAAMmyB,KAAMqB,EACtB,QAAU17B,IAANq6B,EACC,QAAar6B,IAATkI,EAAoBA,EAAOmyB,OAC/B,GAAInyB,IAASmyB,EAAG,MAAM,IAAItJ,MAAM,oCAAoC7oB,SAAYmyB,KAIvF,GAAInyB,IAASu4B,GAAgB,OAC7B,QAAazgC,IAATkI,EAAoB,OAAOA,EAG/B,QAAelI,IAAX8V,IAAyB4lB,EAAS/S,MAAK,EAAEjoB,gBAAqBV,IAAVU,IAAsB,OAG9E,MAAMwb,EAAOiX,GAAS91B,IAAI0B,GAC1B,GAAImd,IAAS+W,GAAQ,MAAO,OAC5B,GAAI/W,IAASgX,IAAWhX,IAAS7Z,GAAQ,MAAO,SAChD,GAAI6Z,IAAS9Y,GAAQ,MAAO,UAK5B,IAAK0S,GAAUqc,GAAS,IAAI9vB,OAAS,EAAG,OAAOq+B,GAAcxkB,GAO7D,QAAelc,IAAX8V,EACF,OAAI0c,GAAU1c,GAAgB4qB,GAAcxkB,GACxCuW,GAAW3c,GAAgB,MAC3BoG,IAAS8W,IAAmB,MAAT6K,IAAiB/C,GAAkBZ,GACnD,SADoE,YAK7E,MAAMpc,EAAS4d,EAASjT,KAAI,EAAE/nB,WAAWA,IAAOgoB,QAAQhoB,QAAoBV,IAAVU,IAClE,OAAIod,EAAO6K,KAAK6J,IAAmBkO,GAAcxkB,GAC7C4B,EAAO6K,KAAK8J,IAAoB,MAChCvW,IAAS8W,IAAmB,MAAT6K,IAAiB/C,GAAkBZ,GACnD,SADoE,WAE7E,CA/LeyG,CAAe5hC,EAAK28B,EAAU5yB,GAO3C,QACmB9I,IAAjB8I,EAAQZ,WACWlI,IAAnB8I,EAAQgN,aACU9V,IAAlB8I,EAAQqpB,OACY,MAApBrpB,EAAQgoB,UACA,OAAR/xB,GACQ,OAARA,GAoMG,UAAwBmJ,KAACA,IAC9B,MAAgB,YAATA,GAA+B,UAATA,GAA6B,SAATA,GAAmBA,IAASk3B,EAC/E,CArMIwB,CAAe,CAAC14B,SAChB,CACA,MAAM4V,EAAS4d,EAASjT,KAAI,EAAE/nB,WAAWA,IAAOgoB,QAAQhoB,QAAoBV,IAAVU,IAC9Dod,EAAO6K,KAAK8J,IACdsC,GACE,0CAA0Ch2B,iGAAmG8hC,GAC3I34B,yQACsQnJ,0FAA4FA,eAAiB8hC,GACnX34B,QAGG4V,EAAO6K,KAAK+J,IACnBqC,GACE,0CAA0Ch2B,uNAAyN8hC,GACjQ34B,8RAC2RnJ,eAAiB8hC,GAC5S34B,QAGG4V,EAAO6K,KAAKgK,KACnBoC,GACE,0CAA0Ch2B,wMAA0M8hC,GAClP34B,6FAC0FnJ,+FAAiGA,eAAiB8hC,GAC5M34B,OAGP,CAMD,OAJAY,EAAQZ,KAAOA,EAIPA,GACN,IAAK,YACL,IAAK,iBACL,IAAK,gBACL,IAAK,gBACL,IAAK,mBACL,IAAK,WACL,IAAK,aACL,IAAK,SACL,IAAK,OACL,IAAK,YACL,IAAK,WACL,IAAK,MACL,IAAK,MACL,IAAK,SACHY,EAAUg4B,GAAWpF,EAAU5yB,EAASuoB,IACxC,MACF,IAAK,WACH,OAAQ8B,GAAS91B,IAAI0B,IACnB,KAAK0kB,GACH3a,EAAUg4B,GAAWpF,EAAU5yB,EAASuoB,IACxC,MACF,KAAKjuB,GACH0F,EAAUg4B,GAAWpF,EAAU5yB,EAASi4B,IAG5C,MACF,IAAK,MACL,IAAK,OACHj4B,EAAUg4B,GAAWpF,EAAU5yB,EAAS0oB,IAI5C,OAAQtpB,GACN,IAAK,YACH,OHxPC,SAA8BnJ,EAAK28B,EAAU5yB,GAClD,OAAO60B,GAAa5+B,EAAKiiC,KAAkBjC,GAAmBrD,EAAU5yB,EAC1E,CGsPam4B,CAAqBliC,EAAK28B,EAAU5yB,GAC7C,IAAK,iBACH,OHtPC,SAAkC/J,EAAK28B,EAAU5yB,GACtD,OAAOu1B,GAAwBt/B,EAAK28B,EAAU,IAAI5yB,EAAS8zB,SAAU,IACvE,CGoPasE,CAAyBniC,EAAK28B,EAAU5yB,GACjD,IAAK,gBACH,OAAOu1B,GAAwBt/B,EAAK28B,EAAU5yB,GAChD,IAAK,gBACH,OH/OC,SACL/J,EACA28B,GACAyF,KAACA,EAAO,GAAEtD,MAAEA,EAAQ,EAAC/nB,OAAEA,EAASmnB,GAAYvB,EAAUmC,EAAQ,EAAIpP,GAAWD,OAAc1lB,IAE3F,OAAO60B,GAAa5+B,EAAKqiC,KAAoBD,KAAMA,GAAQA,GAAQnC,GAActD,EAAU,CACzF5lB,SACA+nB,WACG/0B,GAEP,CGqOau4B,CAAwBtiC,EAAK28B,EAAU5yB,GAChD,IAAK,mBACH,OAAO41B,GAA2B3/B,EAAK28B,EAAU5yB,GACnD,IAAK,cACL,IAAK,UACL,KAAKs2B,GACH,OAAOE,GAAmBvgC,EAAK28B,EAAU5yB,GAC3C,IAAK,WACL,IAAK,aACL,IAAK,SACH,OJhNC,SAA2B/J,EAAK28B,EAAU5yB,GAC/C,OAAO0yB,GAAaz8B,EAAKuiC,KAAe5F,EAAU5yB,EACpD,CI8May4B,CAAkBxiC,EAAK28B,EAAU5yB,GAC1C,IAAK,OACH,OJ9MC,SAAyB/J,EAAK28B,EAAU5yB,GAC7C,OAAO6zB,GAAe59B,EAAK28B,EAAU,IAAI5yB,EAAS8zB,SAAU,IAC9D,CI4Ma4E,CAAgBziC,EAAK28B,EAAU5yB,GACxC,IAAK,YACH,OAAOg0B,GAAqB/9B,EAAK28B,EAAU5yB,GAC7C,IAAK,WACH,OJlMC,SACL/J,EACA28B,GACAvJ,MACEA,EAAKsP,UACLA,QAAsBzhC,IAAVmyB,EAAsB,GAAKA,EAAQ,IAAIA,IAAQ9vB,QAAMwI,EACjEA,EAAI42B,EAASvH,OACbA,EAAS,SAAQpkB,OACjBA,EAAS4nB,GAAoBhC,GAASK,QACtCA,EAAO5B,YACPA,EAAWG,QACXA,IAcF,YAXct6B,IAAVmyB,IACFA,OACkBnyB,IAAhBm6B,EACIC,GAASD,EAAatvB,GACtBsoB,GAAS91B,IAAI0B,KAASi0B,GACtByH,GAAaP,EAAQrvB,QACrB7K,GAEJ8V,EAAOzT,OAAS,IAClByT,EAAS4rB,GAAc5rB,OAAkB9V,IAAVmyB,EAAsB,CAAC9vB,OAAQwI,GAAKsnB,GAAOsP,aAErE3E,GAAqB/9B,EAAK28B,EAAU,CAAC5lB,SAAQqc,QAAOmI,UAASyB,WACtE,CIwKa4F,CAAoB5iC,EAAK28B,EAAU5yB,GAC5C,IAAK,WACH,OJxKC,SACL/J,EACA28B,GACAvJ,MACEA,EAAKtnB,EACLA,QAAc7K,IAAVmyB,EAAsB,GAAKA,EAAQ,IAAIA,IAAQ9vB,QAAM63B,OACzDA,EAAS,SAAQpkB,OACjBA,EAASgmB,GAAgB/8B,EAAK28B,GAASK,QACvCA,EAAO5B,YACPA,EAAWG,QACXA,IAGF,MAAOrvB,EAAKD,GAAOsxB,GAAOxmB,GAC1B,IAAI8rB,EAiBJ,YAhBc5hC,IAAVmyB,GACFyP,EAAaC,GAAM52B,EAAKD,EAAKH,GACzB+2B,EAAW,IAAM32B,GAAK22B,EAAW9b,OAAO,EAAG,GAC3C8b,EAAWA,EAAWv/B,OAAS,IAAM2I,GAAK42B,EAAWE,MACzDj3B,EAAI+2B,EAAWv/B,OAAS,EACxB8vB,OACkBnyB,IAAhBm6B,EACIC,GAASD,EAAatvB,GACtBsoB,GAAS91B,IAAI0B,KAASi0B,GACtByH,GAAaP,EAAQrvB,QACrB7K,IAEN4hC,EAAaxH,GAASc,GAAkBjwB,EAAKD,GAAMH,EAAI,GAAGtC,MAAM,GAAI,GAChE0C,aAAe4jB,OAAM+S,EAAaA,EAAWnZ,KAAK7d,GAAM,IAAIikB,KAAKjkB,OAEnEioB,GAAQlB,GAAS7b,IAAW,GAAG8rB,EAAWtH,UACvCwC,GAAqB/9B,EAAK28B,EAAU,CAAC5lB,OAAQ8rB,EAAYzP,QAAOmI,UAASyB,WAClF,CIwIagG,CAAoBhjC,EAAK28B,EAAU5yB,GAC5C,IAAK,MACH,OAAO6zB,GAAe59B,EAAK28B,EAAU5yB,GACvC,IAAK,MACH,OJhNC,SAAwB/J,EAAK28B,GAAUyF,KAACA,EAAO,GAAErrB,OAAEA,EAAS0nB,GAAe9B,MAAc5yB,IAC9F,OAAO0yB,GAAaz8B,EAAKijC,KAAWb,KAAKA,GAAOzF,EAAU,IAAI5yB,EAASgN,UACzE,CI8MamsB,CAAeljC,EAAK28B,EAAU5yB,GACvC,IAAK,SACH,OJ9MC,SAA2B/J,EAAK28B,GAAUtK,SAACA,EAAW,KAAMtoB,IACjE,OAAO0yB,GAAaz8B,EAAKmjC,KAAc9Q,SAASA,GAAWsK,EAAU5yB,EACvE,CI4Maq5B,CAAkBpjC,EAAK28B,EAAU5yB,GAC1C,IAAK,MACH,OF1VC,SAAwB/J,EAAK28B,EAAU5yB,GAC5C,OAAOq2B,GAAapgC,EAAKqjC,KAAY1G,EAAU5yB,EACjD,CEwVau5B,CAAetjC,EAAK28B,EAAU5yB,GACvC,IAAK,OACH,OFhWC,SAAyB/J,EAAK28B,EAAU5yB,GAC7C,OAAOq2B,GAAapgC,EAAKujC,KAAa5G,EAAU5yB,EAClD,CE8Vay5B,CAAgBxjC,EAAK28B,EAAU5yB,GACxC,IAAK,QACH,OD7SC,SAA0B/J,EAAK28B,GAAU8G,MAACA,EAAQ,GAAGC,QAAEA,EAAU,MAAQ35B,IAC9E,OAAOq3B,GAAWuC,KAAaF,MAAMA,GAAOC,QAAQA,GAAU/G,EAAU5yB,EAAS/J,EACnF,CC2Sa4jC,CAAiB5jC,EAAK28B,EAAU5yB,GACzC,IAAK,OACH,OD3SC,SACL/J,EACA28B,GACA8G,MACEA,EAAQ,GAAGC,QACXA,EAAU,GAAGG,aACbA,EAAeH,EAAOI,aACtBA,GAAuB,OAAR9jC,GAAwB,OAARA,EAAe,EAAI0jC,MAC/C35B,IAGL,OAAOq3B,GACL2C,KAAYN,MAAMA,GAAOI,aAAaA,GAAcC,aAAaA,GACjEnH,EACA5yB,EACA/J,EAEJ,CC0RagkC,CAAgBhkC,EAAK28B,EAAU5yB,GACxC,IAAK,WACH,OAAOqqB,GAAS91B,IAAI0B,KAAS0kB,GJjH1B,CAACvb,KAAM,WAAYuzB,MAAOuH,MIiHmC,CAAC96B,KAAM,YACzE,UAAKlI,EACH,OACF,QACE,MAAM,IAAI+wB,MAAM,uBAAuB7oB,KAE7C,CApIS+6B,CAAYlkC,OAAciB,IAATm9B,OAAqBn9B,EAAY,CAAC,CAACm9B,SAAQ,IAAI1B,GACzE,CAqIA,SAASoF,GAAgB34B,GACvB,MAAuB,iBAATA,EAAoBA,EAAKg7B,YAAch7B,CACvD,CAGA,MAAMu4B,GAAiB,CAACx/B,SAAU,IAAM,cA2DxC,SAASy/B,GAAcxkB,GACrB,OAAQA,GACN,KAAKuH,GACH,MAAO,QACT,KAAKuP,GACH,OAAOoM,GACT,QACE,MAAO,UAEb,CAuCA,SAAS0B,GAAWpF,GAAU5lB,OAACA,KAAWhN,GAAUq6B,GAClD,IAAK,MAAMC,KAAK1H,OACE17B,IAAZojC,EAAE1iC,QACJ0iC,EAAE1iC,MAAQyiC,EAAaC,EAAE1iC,QAG7B,MAAO,CACLoV,YAAmB9V,IAAX8V,EAAuBA,EAASqtB,EAAartB,MAClDhN,EAEP,CAEA,SAASi4B,GAAcjjB,GACrB,OAAO2K,GAAI3K,EAAQ+W,GACrB,CAuBA,SAASwO,IAAY5H,MAACA,EAAKvzB,KAAEA,EAAI4N,OAAEA,EAAMqc,MAAEA,EAAKgI,YAAEA,EAAWrJ,SAAEA,EAAQ8M,UAAEA,EAAS0F,QAAEA,EAAOzF,MAAEA,IAC3F,GAAa,aAAT31B,EAAqB,MAAO,CAACA,KAAM,WAAYhK,MAAQ+zB,GAAMA,EAAGkM,OAASlM,GAAMA,GACnF,MAAM8J,EAAUN,EAAMM,QAAUN,EAAMM,eAAY/7B,EAClD,MAAO,CACLkI,OACA4N,OAAQvN,GAAMuN,WACA9V,IAAVmyB,GAAuB,CAACA,MAAO5pB,GAAM4pB,YACvBnyB,IAAd49B,GAA2B,CAACA,gBAC5B0F,GAAW,CAACA,mBACAtjC,IAAZ+7B,GAAyB,CAACA,mBACb/7B,IAAb8wB,GAA0B,CAACA,oBAGX9wB,IAAhBm6B,GAA6B,CAACA,kBAC9BsB,EAAMG,OAAS,CAACA,MAAOH,EAAMG,iBAGnB57B,IAAV69B,GAAuB,CAACA,QAAOC,WAAW,MAG1CrC,EAAM0F,MAAQ,CAACA,KAAM1F,EAAM0F,WAG3B1F,EAAMmB,UAAY,CAACA,SAAUnB,EAAMmB,eAGnCnB,EAAMrK,UAAY,CAACA,SAAUqK,EAAMrK,eAGnCqK,EAAM+G,OAAS,CAACA,MAAO/G,EAAM+G,QAASxG,MAAOP,EAAMO,YACnDP,EAAMgH,UACPhH,EAAMmH,aACH,CAACA,aAAcnH,EAAMmH,eAAgBC,aAAcpH,EAAMoH,gBACzD,CAACJ,QAAShH,EAAMgH,eAClBhH,EAAM8H,WAAa,CAACA,UAAW9H,EAAM8H,YAAa3mB,KAAM6e,EAAM7e,QAGlE1e,MAAQm8B,GAAMoB,EAAMpB,MAChBoB,EAAM0C,QAAU,CAACA,OAAS9D,GAAMoB,EAAM0C,OAAO9D,IAErD,CCljBA,IAAYmJ,GAMAC,IANZ,SAAYD,GACVA,EAAAA,EAAA,YAAA,GAAA,cACAA,EAAAA,EAAA,gBAAA,GAAA,kBACAA,EAAAA,EAAA,eAAA,GAAA,gBACD,CAJD,CAAYA,KAAAA,GAIX,CAAA,IAED,SAAYC,GACVA,EAAAA,EAAA,IAAA,GAAA,MACAA,EAAAA,EAAA,MAAA,GAAA,QACAA,EAAAA,EAAA,OAAA,GAAA,SACAA,EAAAA,EAAA,KAAA,GAAA,MACD,CALD,CAAYA,KAAAA,GAKX,CAAA,IAKM,IAUMC,GAA2B,MCjBlC,SAAUC,GAAgBC,GAC9B,IACE,IAAMC,EAAY1mC,OAAOgK,KAAKy8B,GAAe,GAE7C,OFweG,SAAe96B,EAAU,IAC9B,IAAI2yB,EACJ,IAAK,MAAM18B,KAAO+J,EAChB,GAAKqqB,GAAStsB,IAAI9H,IACb6yB,GAAe9oB,EAAQ/J,IAA5B,CACA,QAAciB,IAAVy7B,EAAqB,MAAM,IAAI1K,MAAM,qDACzC0K,EAAQ4H,GAAY9C,GAAexhC,EAAK+J,EAAQ/J,IAFJ,CAI9C,QAAciB,IAAVy7B,EAAqB,MAAM,IAAI1K,MAAM,4CACzC,OAAO0K,CACT,CElfWA,IAAK,KACToI,IAAU1mC,OAAAmR,OAAAnR,OAAAmR,OAAA,CAAA,EACNs1B,EAAcC,IACjB,CAAAjI,OAAO,2GAGZ,CAAC,MAAO5+B,GACP,OAAO,IACT,UACF,CAmBM,SAAU8mC,GACdC,EACAC,EACAJ,EACAK,GAEA9mC,OAAOylB,QAvBT,SAAoBohB,EAAaJ,GAC/B,IAAMM,EAAyD,CAAA,EAa/D,OAXIN,EAAcnmC,eAAe,YAC/BymC,EAAO3E,KAAO,WAAA,OAEZqE,EAAc1Q,QAASiR,WAAaT,EAAwB,EAC9DQ,EAAO,gBAAkB,SAACjS,GAAY,OAAK+R,eAAAA,EAAQ9lC,MAAM+zB,EAAE,GAE3DiS,EAAO3E,KAAO,SAACtN,GAAY,MAEX,iBAANA,IAAkBA,aAAC,EAADA,EAAG1E,WAAW,MAAO0E,EAAI+R,aAAA,EAAAA,EAAQ9lC,MAAM+zB,IAG9DiS,CACT,CAQiBE,CAAWJ,EAAQJ,IAAeh1B,SAAQ,SAAAy1B,GAAA,IAAAC,EAAAC,GAAAF,EAAA,GAAEG,EAAIF,EAAA,GAAE5+B,EAAG4+B,EAAA,GAAA,OAElEP,EAAKjkB,MAAM0kB,GAAM,SAACvS,GAAqB,OAErCvsB,EAAIu+B,EAAWhS,EAAgBgS,GAA8BhS,EAAE,MACrE,CCnDA,IAAI3zB,GAAaC,UCAb2Z,GAAIhb,GACJJ,GAAQ8B,GACR+oB,GAAU5mB,GACVS,GAAWkC,GACXhF,GAAWsG,GACXsG,GAAoBpG,GACpBu/B,GDHa,SAAUpmC,GACzB,GAAIA,EAHiB,iBAGM,MAAMC,GAAW,kCAC5C,OAAOD,CACT,ECCI2lB,GAAiBxc,GACjBsgB,GAAqB1Z,GACrB+d,GAA+BtV,GAE/B5T,GAAaqP,GAEboyB,GAHkBtyB,GAGqB,sBAKvCuyB,GAA+B1hC,IAAc,KAAOnG,IAAM,WAC5D,IAAIsvB,EAAQ,GAEZ,OADAA,EAAMsY,KAAwB,EACvBtY,EAAM/f,SAAS,KAAO+f,CAC/B,IAEIwY,GAAqB,SAAUp+B,GACjC,IAAKhF,GAASgF,GAAI,OAAO,EACzB,IAAIq+B,EAAar+B,EAAEk+B,IACnB,YAAsB1kC,IAAf6kC,IAA6BA,EAAald,GAAQnhB,EAC3D,EAOA0R,GAAE,CAAE9O,OAAQ,QAAS4G,OAAO,EAAM/G,MAAO,EAAGiF,QAL9By2B,KAAiCxY,GAA6B,WAKd,CAE5D9f,OAAQ,SAAgBy4B,GACtB,IAGI54B,EAAGoY,EAAGjiB,EAAQ0iC,EAAKC,EAHnBx+B,EAAI9H,GAAS8B,MACbiO,EAAIqZ,GAAmBthB,EAAG,GAC1BqE,EAAI,EAER,IAAKqB,GAAK,EAAG7J,EAASlE,UAAUkE,OAAQ6J,EAAI7J,EAAQ6J,IAElD,GAAI04B,GADJI,GAAW,IAAP94B,EAAW1F,EAAIrI,UAAU+N,IAI3B,IAFA64B,EAAMz5B,GAAkB05B,GACxBP,GAAyB55B,EAAIk6B,GACxBzgB,EAAI,EAAGA,EAAIygB,EAAKzgB,IAAKzZ,IAASyZ,KAAK0gB,GAAGhhB,GAAevV,EAAG5D,EAAGm6B,EAAE1gB,SAElEmgB,GAAyB55B,EAAI,GAC7BmZ,GAAevV,EAAG5D,IAAKm6B,GAI3B,OADAv2B,EAAEpM,OAASwI,EACJ4D,CACR,ICvDH,IACI3Q,GAAOc,GACPiF,GAAY9C,GACZgY,GAA6BrV,GAC7B4S,GAAUtR,GACVwX,GAAUtX,GALNhI,GAUN,CAAEkM,OAAQ,UAAW4E,MAAM,EAAME,OAJO3G,IAIwC,CAChF09B,WAAY,SAAoBxoB,GAC9B,IAAI/E,EAAIlX,KACJod,EAAa7E,GAA2BxS,EAAEmR,GAC1CzB,EAAU2H,EAAW3H,QACrB0B,EAASiG,EAAWjG,OACpB7R,EAASwQ,IAAQ,WACnB,IAAI+H,EAAiBxa,GAAU6T,EAAEzB,SAC7B6H,EAAS,GACTlL,EAAU,EACVmL,EAAY,EAChBvB,GAAQC,GAAU,SAAU1H,GAC1B,IAAI5J,EAAQyH,IACRoL,GAAgB,EACpBD,IACAjgB,GAAKugB,EAAgB3G,EAAG3C,GAASC,MAAK,SAAUtU,GAC1Csd,IACJA,GAAgB,EAChBF,EAAO3S,GAAS,CAAE+5B,OAAQ,YAAaxkC,MAAOA,KAC5Cqd,GAAa9H,EAAQ6H,GACxB,IAAE,SAAU9gB,GACPghB,IACJA,GAAgB,EAChBF,EAAO3S,GAAS,CAAE+5B,OAAQ,WAAYxqB,OAAQ1d,KAC5C+gB,GAAa9H,EAAQ6H,GACjC,GACA,MACQC,GAAa9H,EAAQ6H,EAC7B,IAEI,OADIhY,EAAO9I,OAAO2a,EAAO7R,EAAOpF,OACzBkd,EAAW7I,OACnB,ICzCH,IAAIsL,GAASnjB,GACTiM,GAAwBvK,GACxB8oB,GAAiB3mB,GACjBvD,GAAOkG,GACP8M,GAAaxL,GACb5G,GAAoB8G,GACpBsX,GAAUjV,GACVub,GAAiBtb,GACjBqb,GAAyBzU,GACzBiC,GAAawG,GACb7X,GAAcoT,GACd2T,GAAUzT,GAA0CyT,QAGpD1M,GAFsBlB,GAEiBvR,IACvCoiB,GAHsB7Q,GAGuBnQ,UAEjDm9B,GAAiB,CACfje,eAAgB,SAAUhM,EAAS5K,EAAkBoW,EAAQE,GAC3D,IAAIrW,EAAc2K,GAAQ,SAAUtJ,EAAM6K,GACxCjM,GAAWoB,EAAMnB,GACjB4I,GAAiBzH,EAAM,CACrB1J,KAAMoI,EACNnF,MAAOkV,GAAO,MACdkD,WAAOvjB,EACP8yB,UAAM9yB,EACN0jB,KAAM,IAEH1kB,KAAa4S,EAAK8R,KAAO,GACzBtlB,GAAkBqe,IAAWD,GAAQC,EAAU7K,EAAKgV,GAAQ,CAAEhV,KAAMA,EAAMiL,WAAY6J,GACjG,IAEQjW,EAAYF,EAAY1S,UAExBwK,EAAmB2gB,GAAuB1Y,GAE1CiZ,EAAS,SAAU3X,EAAM7S,EAAK2B,GAChC,IAEI0kC,EAAUj6B,EAFVzD,EAAQW,EAAiBuJ,GACzB8C,EAAQ2wB,EAASzzB,EAAM7S,GAqBzB,OAlBE2V,EACFA,EAAMhU,MAAQA,GAGdgH,EAAMorB,KAAOpe,EAAQ,CACnBvJ,MAAOA,EAAQ4a,GAAQhnB,GAAK,GAC5BA,IAAKA,EACL2B,MAAOA,EACP0kC,SAAUA,EAAW19B,EAAMorB,KAC3Bne,UAAM3U,EACNslC,SAAS,GAEN59B,EAAM6b,QAAO7b,EAAM6b,MAAQ7O,GAC5B0wB,IAAUA,EAASzwB,KAAOD,GAC1B1V,GAAa0I,EAAMgc,OAClB9R,EAAK8R,OAEI,MAAVvY,IAAezD,EAAMyD,MAAMA,GAASuJ,IACjC9C,CACf,EAEQyzB,EAAW,SAAUzzB,EAAM7S,GAC7B,IAGI2V,EAHAhN,EAAQW,EAAiBuJ,GAEzBzG,EAAQ4a,GAAQhnB,GAEpB,GAAc,MAAVoM,EAAe,OAAOzD,EAAMyD,MAAMA,GAEtC,IAAKuJ,EAAQhN,EAAM6b,MAAO7O,EAAOA,EAAQA,EAAMC,KAC7C,GAAID,EAAM3V,MAAQA,EAAK,OAAO2V,CAEtC,EAuFI,OArFAgT,GAAejX,EAAW,CAIxB+B,MAAO,WAKL,IAJA,IACI9K,EAAQW,EADD7H,MAEPyM,EAAOvF,EAAMyD,MACbuJ,EAAQhN,EAAM6b,MACX7O,GACLA,EAAM4wB,SAAU,EACZ5wB,EAAM0wB,WAAU1wB,EAAM0wB,SAAW1wB,EAAM0wB,SAASzwB,UAAO3U,UACpDiN,EAAKyH,EAAMvJ,OAClBuJ,EAAQA,EAAMC,KAEhBjN,EAAM6b,MAAQ7b,EAAMorB,UAAO9yB,EACvBhB,GAAa0I,EAAMgc,KAAO,EAXnBljB,KAYDkjB,KAAO,CAClB,EAID2F,OAAU,SAAUtqB,GAClB,IAAI6S,EAAOpR,KACPkH,EAAQW,EAAiBuJ,GACzB8C,EAAQ2wB,EAASzzB,EAAM7S,GAC3B,GAAI2V,EAAO,CACT,IAAIC,EAAOD,EAAMC,KACb4wB,EAAO7wB,EAAM0wB,gBACV19B,EAAMyD,MAAMuJ,EAAMvJ,OACzBuJ,EAAM4wB,SAAU,EACZC,IAAMA,EAAK5wB,KAAOA,GAClBA,IAAMA,EAAKywB,SAAWG,GACtB79B,EAAM6b,QAAU7O,IAAOhN,EAAM6b,MAAQ5O,GACrCjN,EAAMorB,OAASpe,IAAOhN,EAAMorB,KAAOyS,GACnCvmC,GAAa0I,EAAMgc,OAClB9R,EAAK8R,MACpB,CAAU,QAAShP,CACZ,EAID9F,QAAS,SAAiByZ,GAIxB,IAHA,IAEI3T,EAFAhN,EAAQW,EAAiB7H,MACzB+nB,EAAgB/qB,GAAK6qB,EAAYlqB,UAAUkE,OAAS,EAAIlE,UAAU,QAAK6B,GAEpE0U,EAAQA,EAAQA,EAAMC,KAAOjN,EAAM6b,OAGxC,IAFAgF,EAAc7T,EAAMhU,MAAOgU,EAAM3V,IAAKyB,MAE/BkU,GAASA,EAAM4wB,SAAS5wB,EAAQA,EAAM0wB,QAEhD,EAIDv+B,IAAK,SAAa9H,GAChB,QAASsmC,EAAS7kC,KAAMzB,EACzB,IAGH2oB,GAAejX,EAAWiW,EAAS,CAGjCrpB,IAAK,SAAa0B,GAChB,IAAI2V,EAAQ2wB,EAAS7kC,KAAMzB,GAC3B,OAAO2V,GAASA,EAAMhU,KACvB,EAGDkG,IAAK,SAAa7H,EAAK2B,GACrB,OAAO6oB,EAAO/oB,KAAc,IAARzB,EAAY,EAAIA,EAAK2B,EAC1C,GACC,CAGF8T,IAAK,SAAa9T,GAChB,OAAO6oB,EAAO/oB,KAAME,EAAkB,IAAVA,EAAc,EAAIA,EAAOA,EACtD,IAEC1B,IAAamK,GAAsBsH,EAAW,OAAQ,CACxDjR,cAAc,EACdnC,IAAK,WACH,OAAOgL,EAAiB7H,MAAMkjB,IAC/B,IAEInT,CACR,EACDkX,UAAW,SAAUlX,EAAaD,EAAkBoW,GAClD,IAAI8e,EAAgBl1B,EAAmB,YACnCm1B,EAA6Bzc,GAAuB1Y,GACpDo1B,EAA2B1c,GAAuBwc,GAUtD1iB,GAAevS,EAAaD,GAAkB,SAAU2S,EAAU/G,GAChE7C,GAAiB7Y,KAAM,CACrB0H,KAAMs9B,EACNp8B,OAAQ6Z,EACRvb,MAAO+9B,EAA2BxiB,GAClC/G,KAAMA,EACN4W,UAAM9yB,GAEd,IAAO,WAKD,IAJA,IAAI0H,EAAQg+B,EAAyBllC,MACjC0b,EAAOxU,EAAMwU,KACbxH,EAAQhN,EAAMorB,KAEXpe,GAASA,EAAM4wB,SAAS5wB,EAAQA,EAAM0wB,SAE7C,OAAK19B,EAAM0B,SAAY1B,EAAMorB,KAAOpe,EAAQA,EAAQA,EAAMC,KAAOjN,EAAMA,MAAM6b,OAMjDV,GAAf,SAAT3G,EAA+CxH,EAAM3V,IAC5C,WAATmd,EAAiDxH,EAAMhU,MAC7B,CAACgU,EAAM3V,IAAK2V,EAAMhU,QAFc,IAJ5DgH,EAAM0B,YAASpJ,EACR6iB,QAAuB7iB,GAAW,GAMjD,GAAO0mB,EAAS,UAAY,UAAWA,GAAQ,GAK3CrW,GAAWC,EACZ,GC5McpT,GAKN,OAAO,SAAUssB,GAC1B,OAAO,WAAiB,OAAOA,EAAKhpB,KAAMrC,UAAUkE,OAASlE,UAAU,QAAK6B,EAAW,CACzF,GANuBpB,ICDvB,IAAIgF,GAAc1G,GAEdoB,GAAaC,UCFbuT,GAAa5U,GAEbwN,GAAQvK,KAAKuK,MAEbi7B,GAAY,SAAUvZ,EAAOwZ,GAC/B,IAAIvjC,EAAS+pB,EAAM/pB,OACfwjC,EAASn7B,GAAMrI,EAAS,GAC5B,OAAOA,EAAS,EAAIyjC,GAAc1Z,EAAOwZ,GAAaG,GACpD3Z,EACAuZ,GAAU7zB,GAAWsa,EAAO,EAAGyZ,GAASD,GACxCD,GAAU7zB,GAAWsa,EAAOyZ,GAASD,GACrCA,EAEJ,EAEIE,GAAgB,SAAU1Z,EAAOwZ,GAKnC,IAJA,IAEII,EAAS/2B,EAFT5M,EAAS+pB,EAAM/pB,OACf6J,EAAI,EAGDA,EAAI7J,GAAQ,CAGjB,IAFA4M,EAAI/C,EACJ85B,EAAU5Z,EAAMlgB,GACT+C,GAAK22B,EAAUxZ,EAAMnd,EAAI,GAAI+2B,GAAW,GAC7C5Z,EAAMnd,GAAKmd,IAAQnd,GAEjBA,IAAM/C,MAAKkgB,EAAMnd,GAAK+2B,EAC3B,CAAC,OAAO5Z,CACX,EAEI2Z,GAAQ,SAAU3Z,EAAO6Z,EAAMC,EAAON,GAMxC,IALA,IAAIO,EAAUF,EAAK5jC,OACf+jC,EAAUF,EAAM7jC,OAChBgkC,EAAS,EACTC,EAAS,EAEND,EAASF,GAAWG,EAASF,GAClCha,EAAMia,EAASC,GAAWD,EAASF,GAAWG,EAASF,EACnDR,EAAUK,EAAKI,GAASH,EAAMI,KAAY,EAAIL,EAAKI,KAAYH,EAAMI,KACrED,EAASF,EAAUF,EAAKI,KAAYH,EAAMI,KAC9C,OAAOla,CACX,EAEAma,GAAiBZ,GCzCba,GAFYtpC,GAEQiE,MAAM,mBAE9BslC,KAAmBD,KAAYA,GAAQ,GCFvCE,GAAiB,eAAenpC,KAFvBL,ICELypC,GAFYzpC,GAEOiE,MAAM,wBAE7BylC,KAAmBD,KAAWA,GAAO,GCJjCzuB,GAAIhb,GACJuH,GAAc7F,GACdiF,GAAY9C,GACZrC,GAAWgF,GACX4H,GAAoBtG,GACpB6hC,GLDa,SAAUrgC,EAAGxC,GAC5B,WAAYwC,EAAExC,GAAI,MAAM,IAAI1F,GAAW,0BAA4BsF,GAAYI,GAAK,OAASJ,GAAY4C,GAC3G,EKAIvF,GAAWsG,GACXzK,GAAQ0K,GACRs/B,GAAe14B,GACfqe,GAAsB5V,GACtBkwB,GAAK30B,GACL40B,GAAa10B,GACb20B,GAAK9uB,GACL+uB,GAASzlB,GAETlkB,GAAO,GACP4pC,GAAa1iC,GAAYlH,GAAK8iC,MAC9Bj8B,GAAOK,GAAYlH,GAAK6G,MAGxBgjC,GAAqBtqC,IAAM,WAC7BS,GAAK8iC,UAAKrgC,EACZ,IAEIqnC,GAAgBvqC,IAAM,WACxBS,GAAK8iC,KAAK,KACZ,IAEIiH,GAAgB7a,GAAoB,QAEpC8a,IAAezqC,IAAM,WAEvB,GAAImqC,GAAI,OAAOA,GAAK,GACpB,KAAIF,IAAMA,GAAK,GAAf,CACA,GAAIC,GAAY,OAAO,EACvB,GAAIE,GAAQ,OAAOA,GAAS,IAE5B,IACIM,EAAM34B,EAAKnO,EAAOyK,EADlBrF,EAAS,GAIb,IAAK0hC,EAAO,GAAIA,EAAO,GAAIA,IAAQ,CAGjC,OAFA34B,EAAMtN,OAAOkmC,aAAaD,GAElBA,GACN,KAAK,GAAI,KAAK,GAAI,KAAK,GAAI,KAAK,GAAI9mC,EAAQ,EAAG,MAC/C,KAAK,GAAI,KAAK,GAAIA,EAAQ,EAAG,MAC7B,QAASA,EAAQ,EAGnB,IAAKyK,EAAQ,EAAGA,EAAQ,GAAIA,IAC1B5N,GAAK6G,KAAK,CAAEkgB,EAAGzV,EAAM1D,EAAOsyB,EAAG/8B,GAElC,CAID,IAFAnD,GAAK8iC,MAAK,SAAUx+B,EAAG2M,GAAK,OAAOA,EAAEivB,EAAI57B,EAAE47B,CAAI,IAE1CtyB,EAAQ,EAAGA,EAAQ5N,GAAK8E,OAAQ8I,IACnC0D,EAAMtR,GAAK4N,GAAOmZ,EAAEnB,OAAO,GACvBrd,EAAOqd,OAAOrd,EAAOzD,OAAS,KAAOwM,IAAK/I,GAAU+I,GAG1D,MAAkB,gBAAX/I,CA7BkB,CA8B3B,IAeAoS,GAAE,CAAE9O,OAAQ,QAAS4G,OAAO,EAAM9B,OAbrBk5B,KAAuBC,KAAkBC,KAAkBC,IAapB,CAClDlH,KAAM,SAAcuF,QACA5lC,IAAd4lC,GAAyB/hC,GAAU+hC,GAEvC,IAAIxZ,EAAQ1tB,GAAS8B,MAErB,GAAI+mC,GAAa,YAAqBvnC,IAAd4lC,EAA0BuB,GAAW/a,GAAS+a,GAAW/a,EAAOwZ,GAExF,IAEI8B,EAAav8B,EAFbw8B,EAAQ,GACRC,EAAct8B,GAAkB8gB,GAGpC,IAAKjhB,EAAQ,EAAGA,EAAQy8B,EAAaz8B,IAC/BA,KAASihB,GAAOhoB,GAAKujC,EAAOvb,EAAMjhB,IAQxC,IALA27B,GAAaa,EA3BI,SAAU/B,GAC7B,OAAO,SAAUh7B,EAAGi9B,GAClB,YAAU7nC,IAAN6nC,GAAyB,OACnB7nC,IAAN4K,EAAwB,OACV5K,IAAd4lC,GAAiCA,EAAUh7B,EAAGi9B,IAAM,EACjD5mC,GAAS2J,GAAK3J,GAAS4mC,GAAK,GAAK,CAC5C,CACA,CAoBwBC,CAAelC,IAEnC8B,EAAcp8B,GAAkBq8B,GAChCx8B,EAAQ,EAEDA,EAAQu8B,GAAatb,EAAMjhB,GAASw8B,EAAMx8B,KACjD,KAAOA,EAAQy8B,GAAaf,GAAsBza,EAAOjhB,KAEzD,OAAOihB,CACR,ICvGH,IACI2b,GAAYnpC,GAAuCkN,SAEnD4U,GAAmBhd,GAHfxG,GAaN,CAAEkM,OAAQ,QAAS4G,OAAO,EAAM9B,OAXtBnN,IAIiB,WAE3B,OAAQgP,MAAM,GAAGjE,UACnB,KAI8D,CAC5DA,SAAU,SAAkBH,GAC1B,OAAOo8B,GAAUvnC,KAAMmL,EAAIxN,UAAUkE,OAAS,EAAIlE,UAAU,QAAK6B,EAClE,IAIH0gB,GAAiB,YCpBjB,IACIsnB,GAAOppC,GAAwC6pB,IAD3CvrB,GASN,CAAEkM,OAAQ,QAAS4G,OAAO,EAAM9B,QAPCnN,GAEoB,QAKW,CAChE0nB,IAAK,SAAaJ,GAChB,OAAO2f,GAAKxnC,KAAM6nB,EAAYlqB,UAAUkE,OAAS,EAAIlE,UAAU,QAAK6B,EACrE,ICZH,IACIioC,GAAUrpC,GAAwC8pB,OAD9CxrB,GASN,CAAEkM,OAAQ,QAAS4G,OAAO,EAAM9B,QAPCnN,GAEoB,WAKW,CAChE2nB,OAAQ,SAAgBL,GACtB,OAAO4f,GAAQznC,KAAM6nB,EAAYlqB,UAAUkE,OAAS,EAAIlE,UAAU,QAAK6B,EACxE,ICZH,IAAIgC,GAAW9E,GACX+e,GAAgBrd,GCDhBpB,GAAON,GACPY,GAAOc,GACPF,GAAWqC,GACXmnC,GDCa,SAAU1kC,EAAUvF,EAAIyC,EAAOkhB,GAC9C,IACE,OAAOA,EAAU3jB,EAAG+D,GAAStB,GAAO,GAAIA,EAAM,IAAMzC,EAAGyC,EACxD,CAAC,MAAO1D,GACPif,GAAczY,EAAU,QAASxG,EAClC,CACH,ECNI4e,GAAwB5W,GACxBqM,GAAgBnM,GAChBoG,GAAoB/D,GACpByc,GAAiBxc,GACjBsU,GAAc1N,GACdyN,GAAoBhF,GAEpBqN,GAASnU,MCVTwN,GDca,SAAc4qB,GAC7B,IAAI3hC,EAAI9H,GAASypC,GACbC,EAAiB/2B,GAAc7Q,MAC/BuO,EAAkB5Q,UAAUkE,OAC5BgmC,EAAQt5B,EAAkB,EAAI5Q,UAAU,QAAK6B,EAC7CsoC,OAAoBtoC,IAAVqoC,EACVC,IAASD,EAAQ7qC,GAAK6qC,EAAOt5B,EAAkB,EAAI5Q,UAAU,QAAK6B,IACtE,IAEIqC,EAAQyD,EAAQ8W,EAAMpZ,EAAUmR,EAAMjU,EAFtCsb,EAAiBH,GAAkBrV,GACnC2E,EAAQ,EAGZ,IAAI6Q,GAAoBxb,OAAS0jB,IAAUtI,GAAsBI,GAW/D,IAFA3Z,EAASiJ,GAAkB9E,GAC3BV,EAASsiC,EAAiB,IAAI5nC,KAAK6B,GAAU6hB,GAAO7hB,GAC9CA,EAAS8I,EAAOA,IACpBzK,EAAQ4nC,EAAUD,EAAM7hC,EAAE2E,GAAQA,GAAS3E,EAAE2E,GAC7C6Y,GAAele,EAAQqF,EAAOzK,QAThC,IAFAiU,GADAnR,EAAWsY,GAAYtV,EAAGwV,IACVrH,KAChB7O,EAASsiC,EAAiB,IAAI5nC,KAAS,KAC/Boc,EAAO9e,GAAK6W,EAAMnR,IAAWwX,KAAM7P,IACzCzK,EAAQ4nC,EAAUJ,GAA6B1kC,EAAU6kC,EAAO,CAACzrB,EAAKlc,MAAOyK,IAAQ,GAAQyR,EAAKlc,MAClGsjB,GAAele,EAAQqF,EAAOzK,GAWlC,OADAoF,EAAOzD,OAAS8I,EACTrF,CACT,EC5CQ5I,GAWN,CAAEkM,OAAQ,QAAS4E,MAAM,EAAME,QATCnN,IAEqB,SAAU0b,GAE/D1M,MAAMwN,KAAKd,EACb,KAIgE,CAC9Dc,KAAMA,KCXR,IAAAgrB,GAAiB,gDCAb/pC,GAAyBI,GACzBqC,GAAWF,GACXwnC,GAAc7kC,GAEd8E,GALctL,GAKQ,GAAGsL,SACzBggC,GAAQC,OAAO,KAAOF,GAAc,MACpCG,GAAQD,OAAO,QAAUF,GAAc,MAAQA,GAAc,OAG7D/8B,GAAe,SAAUvD,GAC3B,OAAO,SAAUyD,GACf,IAAI2B,EAASpM,GAASzC,GAAuBkN,IAG7C,OAFW,EAAPzD,IAAUoF,EAAS7E,GAAQ6E,EAAQm7B,GAAO,KACnC,EAAPvgC,IAAUoF,EAAS7E,GAAQ6E,EAAQq7B,GAAO,OACvCr7B,CACX,CACA,EAEAs7B,GAAiB,CAGfvkB,MAAO5Y,GAAa,GAGpB6Y,IAAK7Y,GAAa,GAGlBonB,KAAMpnB,GAAa,IC5BjBgW,GAAuBtkB,GAAsCmC,OAC7DvC,GAAQ8B,GACR2pC,GAAcxnC,GCDd6nC,GAAQhqC,GAAoCg0B,KADxC11B,GAMN,CAAEkM,OAAQ,SAAU4G,OAAO,EAAM9B,ODElB,SAAUge,GACzB,OAAOpvB,IAAM,WACX,QAASyrC,GAAYrc,MANf,cAOGA,MACH1K,IAAwB+mB,GAAYrc,GAAa5sB,OAAS4sB,CACpE,GACA,CCR2C2c,CAAuB,SAAW,CAC3EjW,KAAM,WACJ,OAAOgW,GAAMpoC,KACd,ICNI,aCuBDsoC,GAAmB,yBAEnBC,GAAgC,CACpCC,SAAS,EACTC,aAAc,KACdC,MxBhB6C,GwBiB7CC,OxBhB8C,GwBiB9CC,OxBhB8C,EwBiB9CnW,OxBhB8C,EwBiB9CoW,cAAc,GAGKC,GAAU,WAW7B,SAAAA,EAAYC,gGAAoBC,MAAAF,gBAVhC9oC,KAAIlB,KAAG,aAWLkB,KAAK+oC,SAAWA,EAChB/oC,KAAKipC,KAAO,KACZjpC,KAAKkpC,OAAQ,EACblpC,KAAKsI,QAAUigC,EACjB,WA0CC,SA1CAO,IAAA,CAAA,CAAAvqC,IAAA,QAAA2B,MAED,SAAMipC,GACJnpC,KAAKsI,QAAe3L,OAAAmR,OAAAnR,OAAAmR,OAAA,CAAA,EAAA9N,KAAKsI,SAAY6gC,EACvC,GAAC,CAAA5qC,IAAA,QAAA2B,MAED,WACE,IAAAkpC,EAAkCppC,KAAKsI,QAA/BkgC,EAAOY,EAAPZ,QAASC,EAAYW,EAAZX,aAEjB,IAAKD,GAAYC,GAAgBY,EAAOZ,GAAct4B,QACpD,OAAOnQ,KAAKspC,UAGdtpC,KAAKkpC,OAAQ,EAEblpC,KAAKipC,KAAOI,EACVZ,GAAgBzoC,KAAK+oC,SAASzgC,QAAQA,QAAQmgC,cAG5CzoC,KAAKipC,KAAKI,OAAOf,IAAkBn4B,QACrCnQ,KAAKipC,KAAOjpC,KAAKipC,KACdM,OAAO,OACPC,KAAK,QAASlB,GAAiBvgC,MAAM,IAExC/H,KAAKipC,KAAOjpC,KAAKipC,KAAKI,OAAOf,IAG/B,IAAMh0B,EAAO6X,GAAAnsB,gBAAA1C,KAAA0C,MAKb,OAHAA,KAAKipC,KAAKQ,UAAU,KAAKC,SACzB1pC,KAAKipC,KAAKM,QAAO,WAAA,OAAMj1B,EAAKA,UAErBW,QAAQQ,SACjB,GAAC,CAAAlX,IAAA,UAAA2B,MAED,WAME,OALkB,OAAdF,KAAKipC,OACPjpC,KAAKipC,KAAKS,SACV1pC,KAAKipC,KAAO,MAGPh0B,QAAQQ,SACjB,uFAACqzB,CAAA,CA1D4B,2CA6DrBx0B,EAAOuL,EAAO,OACdob,EAAQkI,GAAgBnjC,KAAK+oC,SAASzgC,QAAQA,QAAQ2yB,OAC5D0O,EAEI3pC,KAAKsI,QADPogC,EAAKiB,EAALjB,MAAOC,EAAMgB,EAANhB,OAAQC,EAAMe,EAANf,OAAQC,EAAYc,EAAZd,aAGnBe,EAAUC,GAAO5O,EAAMtJ,OAyB7B,OAxBIkX,GACFe,EAAWE,QAAQ,MAGrBx1B,EACGk1B,KAAK,QCvGoB,gBDuGGzhC,MAAM,IAClCyhC,KACC,QACAI,EAAW/nC,OAAS6mC,GAASkB,EAAW/nC,OAAS,GAAK+mC,GAEvDY,KAAK,SAAUb,GAElBr0B,EACGm1B,UAAU,QACVh9B,KAAKm9B,GACL3hC,MACC,SAACuN,GAAU,OAAKA,EAAM+zB,OAAO,QAAQjsC,MAAK,SAACysC,GAAO,OAEhD5d,GAAA6d,EAAeC,GAAA,IAAAC,IAAA5sC,KAAf0sC,EAAgBD,EAAI9O,KAAO,IAC7B,SAACkP,GAAW,OAAKA,EACdV,UAAU,QACVnsC,MAAK,SAACysC,GAAO,OAAK5d,GAAA6d,EAAIC,GAAA,IAAAC,IAAJ5sC,KAAA0sC,EAAgBD,EAAI9O,SAGtC3mB,CACT,EAAC41B,GAAA,SAEUE,EAAgBnP,GAAU,IAAAoP,EAAArqC,KACnCsqC,EAEItqC,KAAKsI,QADPogC,EAAK4B,EAAL5B,MAAOC,EAAM2B,EAAN3B,OAAQlW,EAAM6X,EAAN7X,OAAQmW,EAAM0B,EAAN1B,OAGzB,OAAOwB,EACJZ,KAAK,QAASd,GACdc,KAAK,SAAUb,GACfa,KAAK,WAAO39B,OD1Ia,gBC0IW9D,MAAM,GAAE,QAC5CyhC,KAAK,KAAM/W,GACX+W,KAAK,KAAM/W,GACX+W,KAAK,KAAK,SAACe,EAAS7+B,GAAS,OAAKA,GAAKg9B,EAAQE,EAAO,IACtDY,KAAK,IAAK,GACVlsC,MAAK,SAACkoC,GACLlC,GAAgBkC,EAASvK,EAAOoP,EAAKtB,SAASzgC,QAAQA,QAAQ2yB,MAChE,GACJ,SAAC6N","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199]} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.js b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.js new file mode 100644 index 0000000..e3402f9 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.js @@ -0,0 +1 @@ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e(require("d3-selection"),require("d3")):"function"==typeof define&&define.amd?define(["d3-selection","d3"],e):(t="undefined"!=typeof globalThis?globalThis:t||self).LegendLite=e(t.d3,t.d3)}(this,(function(t,e){"use strict";function n(t,e){for(var n=0;nt.length)&&(e=t.length);for(var n=0,r=new Array(e);n0&&K[0]<4?1:+(K[0]+K[1])),!J&&Tt&&(!(K=Tt.match(/Edge\/(\d+)/))||K[1]>=74)&&(K=Tt.match(/Chrome\/(\d+)/))&&(J=+K[1]);var kt=J,At=kt,Ct=s,It=F.String,Lt=!!Object.getOwnPropertySymbols&&!Ct((function(){var t=Symbol("symbol detection");return!It(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&At&&At<41})),Nt=Lt&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,Bt=St,Dt=D,Gt=Ot,Ft=Object,qt=Nt?function(t){return"symbol"==typeof t}:function(t){var e=Bt("Symbol");return Dt(e)&&Gt(e.prototype,Ft(t))},_t=String,$t=function(t){try{return _t(t)}catch(t){return"Object"}},zt=D,Yt=$t,Wt=TypeError,Ut=function(t){if(zt(t))return t;throw new Wt(Yt(t)+" is not a function")},Ht=Ut,Vt=g,Kt=function(t,e){var n=t[e];return Vt(n)?void 0:Ht(n)},Jt=mt,Xt=D,Qt=rt,Zt=TypeError,te={exports:{}},ee=W;(te.exports=function(t,e){return ee[t]||(ee[t]=void 0!==e?e:{})})("versions",[]).push({version:"3.34.0",mode:"global",copyright:"© 2014-2023 Denis Pushkarev (zloirock.ru)",license:"https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE",source:"https://github.com/zloirock/core-js"});var ne=te.exports,re=y,oe=0,ie=Math.random(),ae=re(1..toString),ue=function(t){return"Symbol("+(void 0===t?"":t)+")_"+ae(++oe+ie,36)},ce=ne,se=P,le=ue,fe=Lt,de=Nt,pe=F.Symbol,he=ce("wks"),ve=de?pe.for||pe:pe&&pe.withoutSetter||le,ye=function(t){return se(he,t)||(he[t]=fe&&se(pe,t)?pe[t]:ve("Symbol."+t)),he[t]},ge=mt,me=rt,be=qt,we=Kt,Se=function(t,e){var n,r;if("string"===e&&Xt(n=t.toString)&&!Qt(r=Jt(n,t)))return r;if(Xt(n=t.valueOf)&&!Qt(r=Jt(n,t)))return r;if("string"!==e&&Xt(n=t.toString)&&!Qt(r=Jt(n,t)))return r;throw new Zt("Can't convert object to primitive value")},Oe=TypeError,je=ye("toPrimitive"),Ee=function(t,e){if(!me(t)||be(t))return t;var n,r=we(t,je);if(r){if(void 0===e&&(e="default"),n=ge(r,t,e),!me(n)||be(n))return n;throw new Oe("Can't convert object to primitive value")}return void 0===e&&(e="number"),Se(t,e)},Te=qt,Pe=function(t){var e=Ee(t,"string");return Te(e)?e:e+""},xe=l,Re=lt,Me=ft,ke=vt,Ae=Pe,Ce=TypeError,Ie=Object.defineProperty,Le=Object.getOwnPropertyDescriptor,Ne="enumerable",Be="configurable",De="writable";ot.f=xe?Me?function(t,e,n){if(ke(t),e=Ae(e),ke(n),"function"==typeof t&&"prototype"===e&&"value"in n&&De in n&&!n[De]){var r=Le(t,e);r&&r[De]&&(t[e]=n.value,n={configurable:Be in n?n[Be]:r[Be],enumerable:Ne in n?n[Ne]:r[Ne],writable:!1})}return Ie(t,e,n)}:Ie:function(t,e,n){if(ke(t),e=Ae(e),ke(n),Re)try{return Ie(t,e,n)}catch(t){}if("get"in n||"set"in n)throw new Ce("Accessors not supported");return"value"in n&&(t[e]=n.value),t};var Ge,Fe,qe,_e=function(t,e){return{enumerable:!(1&t),configurable:!(2&t),writable:!(4&t),value:e}},$e=ot,ze=_e,Ye=l?function(t,e,n){return $e.f(t,e,ze(1,n))}:function(t,e,n){return t[e]=n,t},We=ue,Ue=ne("keys"),He=function(t){return Ue[t]||(Ue[t]=We(t))},Ve={},Ke=tt,Je=F,Xe=rt,Qe=Ye,Ze=P,tn=W,en=He,nn=Ve,rn="Object already initialized",on=Je.TypeError,an=Je.WeakMap;if(Ke||tn.state){var un=tn.state||(tn.state=new an);un.get=un.get,un.has=un.has,un.set=un.set,Ge=function(t,e){if(un.has(t))throw new on(rn);return e.facade=t,un.set(t,e),e},Fe=function(t){return un.get(t)||{}},qe=function(t){return un.has(t)}}else{var cn=en("state");nn[cn]=!0,Ge=function(t,e){if(Ze(t,cn))throw new on(rn);return e.facade=t,Qe(t,cn,e),e},Fe=function(t){return Ze(t,cn)?t[cn]:{}},qe=function(t){return Ze(t,cn)}}var sn={set:Ge,get:Fe,has:qe,enforce:function(t){return qe(t)?Fe(t):Ge(t,{})},getterFor:function(t){return function(e){var n;if(!Xe(e)||(n=Fe(e)).type!==t)throw new on("Incompatible receiver, "+t+" required");return n}}},ln=y,fn=s,dn=D,pn=P,hn=l,vn=C.CONFIGURABLE,yn=X,gn=sn.enforce,mn=sn.get,bn=String,wn=Object.defineProperty,Sn=ln("".slice),On=ln("".replace),jn=ln([].join),En=hn&&!fn((function(){return 8!==wn((function(){}),"length",{value:8}).length})),Tn=String(String).split("String"),Pn=I.exports=function(t,e,n){"Symbol("===Sn(bn(e),0,7)&&(e="["+On(bn(e),/^Symbol\(([^)]*)\)/,"$1")+"]"),n&&n.getter&&(e="get "+e),n&&n.setter&&(e="set "+e),(!pn(t,"name")||vn&&t.name!==e)&&(hn?wn(t,"name",{value:e,configurable:!0}):t.name=e),En&&n&&pn(n,"arity")&&t.length!==n.arity&&wn(t,"length",{value:n.arity});try{n&&pn(n,"constructor")&&n.constructor?hn&&wn(t,"prototype",{writable:!1}):t.prototype&&(t.prototype=void 0)}catch(t){}var r=gn(t);return pn(r,"source")||(r.source=jn(Tn,"string"==typeof e?e:"")),t};Function.prototype.toString=Pn((function(){return dn(this)&&mn(this).source||yn(this)}),"toString");var xn=I.exports,Rn=xn,Mn=ot,kn=function(t,e,n){return n.get&&Rn(n.get,e,{getter:!0}),n.set&&Rn(n.set,e,{setter:!0}),Mn.f(t,e,n)},An=l,Cn=C.EXISTS,In=y,Ln=kn,Nn=Function.prototype,Bn=In(Nn.toString),Dn=/function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/,Gn=In(Dn.exec);An&&!Cn&&Ln(Nn,"name",{configurable:!0,get:function(){try{return Gn(Dn,Bn(this))[1]}catch(t){return""}}});var Fn={},qn={},_n={}.propertyIsEnumerable,$n=Object.getOwnPropertyDescriptor,zn=$n&&!_n.call({1:2},1);qn.f=zn?function(t){var e=$n(this,t);return!!e&&e.enumerable}:_n;var Yn=y,Wn=Yn({}.toString),Un=Yn("".slice),Hn=function(t){return Un(Wn(t),8,-1)},Vn=s,Kn=Hn,Jn=Object,Xn=y("".split),Qn=Vn((function(){return!Jn("z").propertyIsEnumerable(0)}))?function(t){return"String"===Kn(t)?Xn(t,""):Jn(t)}:Jn,Zn=Qn,tr=w,er=function(t){return Zn(tr(t))},nr=l,rr=mt,or=qn,ir=_e,ar=er,ur=Pe,cr=P,sr=lt,lr=Object.getOwnPropertyDescriptor;Fn.f=nr?lr:function(t,e){if(t=ar(t),e=ur(e),sr)try{return lr(t,e)}catch(t){}if(cr(t,e))return ir(!rr(or.f,t,e),t[e])};var fr=D,dr=ot,pr=xn,hr=$,vr=function(t,e,n,r){r||(r={});var o=r.enumerable,i=void 0!==r.name?r.name:e;if(fr(n)&&pr(n,i,r),r.global)o?t[e]=n:hr(e,n);else{try{r.unsafe?t[e]&&(o=!0):delete t[e]}catch(t){}o?t[e]=n:dr.f(t,e,{value:n,enumerable:!1,configurable:!r.nonConfigurable,writable:!r.nonWritable})}return t},yr={},gr=Math.ceil,mr=Math.floor,br=Math.trunc||function(t){var e=+t;return(e>0?mr:gr)(e)},wr=function(t){var e=+t;return e!=e||0===e?0:br(e)},Sr=wr,Or=Math.max,jr=Math.min,Er=function(t,e){var n=Sr(t);return n<0?Or(n+e,0):jr(n,e)},Tr=wr,Pr=Math.min,xr=function(t){return t>0?Pr(Tr(t),9007199254740991):0},Rr=xr,Mr=function(t){return Rr(t.length)},kr=er,Ar=Er,Cr=Mr,Ir=function(t){return function(e,n,r){var o,i=kr(e),a=Cr(i),u=Ar(r,a);if(t&&n!=n){for(;a>u;)if((o=i[u++])!=o)return!0}else for(;a>u;u++)if((t||u in i)&&i[u]===n)return t||u||0;return!t&&-1}},Lr={includes:Ir(!0),indexOf:Ir(!1)},Nr=P,Br=er,Dr=Lr.indexOf,Gr=Ve,Fr=y([].push),qr=function(t,e){var n,r=Br(t),o=0,i=[];for(n in r)!Nr(Gr,n)&&Nr(r,n)&&Fr(i,n);for(;e.length>o;)Nr(r,n=e[o++])&&(~Dr(i,n)||Fr(i,n));return i},_r=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],$r=qr,zr=_r.concat("length","prototype");yr.f=Object.getOwnPropertyNames||function(t){return $r(t,zr)};var Yr={};Yr.f=Object.getOwnPropertySymbols;var Wr=St,Ur=yr,Hr=Yr,Vr=vt,Kr=y([].concat),Jr=Wr("Reflect","ownKeys")||function(t){var e=Ur.f(Vr(t)),n=Hr.f;return n?Kr(e,n(t)):e},Xr=P,Qr=Jr,Zr=Fn,to=ot,eo=s,no=D,ro=/#|\.prototype\./,oo=function(t,e){var n=ao[io(t)];return n===co||n!==uo&&(no(e)?eo(e):!!e)},io=oo.normalize=function(t){return String(t).replace(ro,".").toLowerCase()},ao=oo.data={},uo=oo.NATIVE="N",co=oo.POLYFILL="P",so=oo,lo=F,fo=Fn.f,po=Ye,ho=vr,vo=$,yo=function(t,e,n){for(var r=Qr(e),o=to.f,i=Zr.f,a=0;ao;)for(var u,c=ko(arguments[o++]),s=i?Io(Po(c),i(c)):Po(c),l=s.length,f=0;l>f;)u=s[f++],Oo&&!Eo(a,c,u)||(n[u]=c[u]);return n}:Ao,No=Lo;mo({target:"Object",stat:!0,arity:2,forced:Object.assign!==No},{assign:No});var Bo={};Bo[ye("toStringTag")]="z";var Do="[object z]"===String(Bo),Go=Do,Fo=D,qo=Hn,_o=ye("toStringTag"),$o=Object,zo="Arguments"===qo(function(){return arguments}()),Yo=Go?qo:function(t){var e,n,r;return void 0===t?"Undefined":null===t?"Null":"string"==typeof(n=function(t,e){try{return t[e]}catch(t){}}(e=$o(t),_o))?n:zo?qo(e):"Object"===(r=qo(e))&&Fo(e.callee)?"Arguments":r},Wo=Yo,Uo=Do?{}.toString:function(){return"[object "+Wo(this)+"]"};Do||vr(Object.prototype,"toString",Uo,{unsafe:!0});var Ho="process"===Hn(F.process),Vo=y,Ko=Ut,Jo=D,Xo=String,Qo=TypeError,Zo=function(t,e,n){try{return Vo(Ko(Object.getOwnPropertyDescriptor(t,e)[n]))}catch(t){}},ti=vt,ei=function(t){if("object"==typeof t||Jo(t))return t;throw new Qo("Can't set "+Xo(t)+" as a prototype")},ni=Object.setPrototypeOf||("__proto__"in{}?function(){var t,e=!1,n={};try{(t=Zo(Object.prototype,"__proto__","set"))(n,[]),e=n instanceof Array}catch(t){}return function(n,r){return ti(n),ei(r),e?t(n,r):n.__proto__=r,n}}():void 0),ri=ot.f,oi=P,ii=ye("toStringTag"),ai=function(t,e,n){t&&!n&&(t=t.prototype),t&&!oi(t,ii)&&ri(t,ii,{configurable:!0,value:e})},ui=St,ci=kn,si=l,li=ye("species"),fi=function(t){var e=ui(t);si&&e&&!e[li]&&ci(e,li,{configurable:!0,get:function(){return this}})},di=Ot,pi=TypeError,hi=function(t,e){if(di(e,t))return t;throw new pi("Incorrect invocation")},vi=y,yi=s,gi=D,mi=Yo,bi=X,wi=function(){},Si=[],Oi=St("Reflect","construct"),ji=/^\s*(?:class|function)\b/,Ei=vi(ji.exec),Ti=!ji.test(wi),Pi=function(t){if(!gi(t))return!1;try{return Oi(wi,Si,t),!0}catch(t){return!1}},xi=function(t){if(!gi(t))return!1;switch(mi(t)){case"AsyncFunction":case"GeneratorFunction":case"AsyncGeneratorFunction":return!1}try{return Ti||!!Ei(ji,bi(t))}catch(t){return!0}};xi.sham=!0;var Ri,Mi,ki,Ai,Ci=!Oi||yi((function(){var t;return Pi(Pi.call)||!Pi(Object)||!Pi((function(){t=!0}))||t}))?xi:Pi,Ii=Ci,Li=$t,Ni=TypeError,Bi=vt,Di=function(t){if(Ii(t))return t;throw new Ni(Li(t)+" is not a constructor")},Gi=g,Fi=ye("species"),qi=f,_i=Function.prototype,$i=_i.apply,zi=_i.call,Yi="object"==typeof Reflect&&Reflect.apply||(qi?zi.bind($i):function(){return zi.apply($i,arguments)}),Wi=Hn,Ui=y,Hi=function(t){if("Function"===Wi(t))return Ui(t)},Vi=Ut,Ki=f,Ji=Hi(Hi.bind),Xi=function(t,e){return Vi(t),void 0===e?t:Ki?Ji(t,e):function(){return t.apply(e,arguments)}},Qi=St("document","documentElement"),Zi=y([].slice),ta=TypeError,ea=/(?:ipad|iphone|ipod).*applewebkit/i.test(jt),na=F,ra=Yi,oa=Xi,ia=D,aa=P,ua=s,ca=Qi,sa=Zi,la=ct,fa=function(t,e){if(ti;i++)if((u=g(t[i]))&&Vc(ts,u))return u;return new Zc(!1)}r=Kc(t,o)}for(c=d?t.next:r.next;!(s=zc(c,r)).done;){try{u=g(s.value)}catch(t){Xc(r,"throw",t)}if("object"==typeof u&&u&&Vc(ts,u))return u}return new Zc(!1)},ns=ye("iterator"),rs=!1;try{var os=0,is={next:function(){return{done:!!os++}},return:function(){rs=!0}};is[ns]=function(){return this},Array.from(is,(function(){throw 2}))}catch(t){}var as=function(t,e){try{if(!e&&!rs)return!1}catch(t){return!1}var n=!1;try{var r={};r[ns]=function(){return{next:function(){return{done:n=!0}}}},t(r)}catch(t){}return n},us=ru,cs=bu.CONSTRUCTOR||!as((function(t){us.all(t).then(void 0,(function(){}))})),ss=mt,ls=Ut,fs=wu,ds=nu,ps=es;mo({target:"Promise",stat:!0,forced:cs},{all:function(t){var e=this,n=fs.f(e),r=n.resolve,o=n.reject,i=ds((function(){var n=ls(e.resolve),i=[],a=0,u=1;ps(t,(function(t){var c=a++,s=!1;u++,ss(n,e,t).then((function(t){s||(s=!0,i[c]=t,--u||r(i))}),o)})),--u||r(i)}));return i.error&&o(i.value),n.promise}});var hs=mo,vs=bu.CONSTRUCTOR,ys=ru,gs=St,ms=D,bs=vr,ws=ys&&ys.prototype;if(hs({target:"Promise",proto:!0,forced:vs,real:!0},{catch:function(t){return this.then(void 0,t)}}),ms(ys)){var Ss=gs("Promise").prototype.catch;ws.catch!==Ss&&bs(ws,"catch",Ss,{unsafe:!0})}var Os=mt,js=Ut,Es=wu,Ts=nu,Ps=es;mo({target:"Promise",stat:!0,forced:cs},{race:function(t){var e=this,n=Es.f(e),r=n.reject,o=Ts((function(){var o=js(e.resolve);Ps(t,(function(t){Os(o,e,t).then(n.resolve,r)}))}));return o.error&&r(o.value),n.promise}});var xs=mt,Rs=wu;mo({target:"Promise",stat:!0,forced:bu.CONSTRUCTOR},{reject:function(t){var e=Rs.f(this);return xs(e.reject,void 0,t),e.promise}});var Ms=vt,ks=rt,As=wu,Cs=mo,Is=bu.CONSTRUCTOR,Ls=function(t,e){if(Ms(t),ks(e)&&e.constructor===t)return e;var n=As.f(t);return(0,n.resolve)(e),n.promise};St("Promise"),Cs({target:"Promise",stat:!0,forced:Is},{resolve:function(t){return Ls(this,t)}});var Ns={},Bs=l,Ds=ft,Gs=ot,Fs=vt,qs=er,_s=So;Ns.f=Bs&&!Ds?Object.defineProperties:function(t,e){Fs(t);for(var n,r=qs(e),o=_s(e),i=o.length,a=0;i>a;)Gs.f(t,n=o[a++],r[n]);return t};var $s,zs=vt,Ys=Ns,Ws=_r,Us=Ve,Hs=Qi,Vs=ct,Ks="prototype",Js="script",Xs=He("IE_PROTO"),Qs=function(){},Zs=function(t){return"<"+Js+">"+t+""},tl=function(t){t.write(Zs("")),t.close();var e=t.parentWindow.Object;return t=null,e},el=function(){try{$s=new ActiveXObject("htmlfile")}catch(t){}var t,e,n;el="undefined"!=typeof document?document.domain&&$s?tl($s):(e=Vs("iframe"),n="java"+Js+":",e.style.display="none",Hs.appendChild(e),e.src=String(n),(t=e.contentWindow.document).open(),t.write(Zs("document.F=Object")),t.close(),t.F):tl($s);for(var r=Ws.length;r--;)delete el[Ks][Ws[r]];return el()};Us[Xs]=!0;var nl=Object.create||function(t,e){var n;return null!==t?(Qs[Ks]=zs(t),n=new Qs,Qs[Ks]=null,n[Xs]=t):n=el(),void 0===e?n:Ys.f(n,e)},rl=ye,ol=nl,il=ot.f,al=rl("unscopables"),ul=Array.prototype;void 0===ul[al]&&il(ul,al,{configurable:!0,value:ol(null)});var cl,sl,ll,fl=function(t){ul[al][t]=!0},dl=!s((function(){function t(){}return t.prototype.constructor=null,Object.getPrototypeOf(new t)!==t.prototype})),pl=P,hl=D,vl=j,yl=dl,gl=He("IE_PROTO"),ml=Object,bl=ml.prototype,wl=yl?ml.getPrototypeOf:function(t){var e=vl(t);if(pl(e,gl))return e[gl];var n=e.constructor;return hl(n)&&e instanceof n?n.prototype:e instanceof ml?bl:null},Sl=s,Ol=D,jl=rt,El=wl,Tl=vr,Pl=ye("iterator"),xl=!1;[].keys&&("next"in(ll=[].keys())?(sl=El(El(ll)))!==Object.prototype&&(cl=sl):xl=!0);var Rl=!jl(cl)||Sl((function(){var t={};return cl[Pl].call(t)!==t}));Rl&&(cl={}),Ol(cl[Pl])||Tl(cl,Pl,(function(){return this}));var Ml={IteratorPrototype:cl,BUGGY_SAFARI_ITERATORS:xl},kl=Ml.IteratorPrototype,Al=nl,Cl=_e,Il=ai,Ll=wc,Nl=function(){return this},Bl=mo,Dl=mt,Gl=D,Fl=function(t,e,n,r){var o=e+" Iterator";return t.prototype=Al(kl,{next:Cl(+!r,n)}),Il(t,o,!1),Ll[o]=Nl,t},ql=wl,_l=ni,$l=ai,zl=Ye,Yl=vr,Wl=wc,Ul=C.PROPER,Hl=C.CONFIGURABLE,Vl=Ml.IteratorPrototype,Kl=Ml.BUGGY_SAFARI_ITERATORS,Jl=ye("iterator"),Xl="keys",Ql="values",Zl="entries",tf=function(){return this},ef=function(t,e,n,r,o,i,a){Fl(n,e,r);var u,c,s,l=function(t){if(t===o&&v)return v;if(!Kl&&t&&t in p)return p[t];switch(t){case Xl:case Ql:case Zl:return function(){return new n(this,t)}}return function(){return new n(this)}},f=e+" Iterator",d=!1,p=t.prototype,h=p[Jl]||p["@@iterator"]||o&&p[o],v=!Kl&&h||l(o),y="Array"===e&&p.entries||h;if(y&&(u=ql(y.call(new t)))!==Object.prototype&&u.next&&(ql(u)!==Vl&&(_l?_l(u,Vl):Gl(u[Jl])||Yl(u,Jl,tf)),$l(u,f,!0)),Ul&&o===Ql&&h&&h.name!==Ql&&(Hl?zl(p,"name",Ql):(d=!0,v=function(){return Dl(h,this)})),o)if(c={values:l(Ql),keys:i?v:l(Xl),entries:l(Zl)},a)for(s in c)(Kl||d||!(s in p))&&Yl(p,s,c[s]);else Bl({target:e,proto:!0,forced:Kl||d},c);return p[Jl]!==v&&Yl(p,Jl,v,{name:o}),Wl[e]=v,c},nf=function(t,e){return{value:t,done:e}},rf=er,of=fl,af=wc,uf=sn,cf=ot.f,sf=ef,lf=nf,ff=l,df="Array Iterator",pf=uf.set,hf=uf.getterFor(df),vf=sf(Array,"Array",(function(t,e){pf(this,{type:df,target:rf(t),index:0,kind:e})}),(function(){var t=hf(this),e=t.target,n=t.index++;if(!e||n>=e.length)return t.target=void 0,lf(void 0,!0);switch(t.kind){case"keys":return lf(n,!1);case"values":return lf(e[n],!1)}return lf([n,e[n]],!1)}),"values"),yf=af.Arguments=af.Array;if(of("keys"),of("values"),of("entries"),ff&&"values"!==yf.name)try{cf(yf,"name",{value:"values"})}catch(t){}var gf=Yo,mf=String,bf=function(t){if("Symbol"===gf(t))throw new TypeError("Cannot convert a Symbol value to a string");return mf(t)},wf=y,Sf=wr,Of=bf,jf=w,Ef=wf("".charAt),Tf=wf("".charCodeAt),Pf=wf("".slice),xf=function(t){return function(e,n){var r,o,i=Of(jf(e)),a=Sf(n),u=i.length;return a<0||a>=u?t?"":void 0:(r=Tf(i,a))<55296||r>56319||a+1===u||(o=Tf(i,a+1))<56320||o>57343?t?Ef(i,a):r:t?Pf(i,a,a+2):o-56320+(r-55296<<10)+65536}},Rf={codeAt:xf(!1),charAt:xf(!0)}.charAt,Mf=bf,kf=sn,Af=ef,Cf=nf,If="String Iterator",Lf=kf.set,Nf=kf.getterFor(If);Af(String,"String",(function(t){Lf(this,{type:If,string:Mf(t),index:0})}),(function(){var t,e=Nf(this),n=e.string,r=e.index;return r>=n.length?Cf(void 0,!0):(t=Rf(n,r),e.index+=t.length,Cf(t,!1))}));var Bf={exports:{}},Df={},Gf=Pe,Ff=ot,qf=_e,_f=function(t,e,n){var r=Gf(e);r in t?Ff.f(t,r,qf(0,n)):t[r]=n},$f=Er,zf=Mr,Yf=_f,Wf=Array,Uf=Math.max,Hf=function(t,e,n){for(var r=zf(t),o=$f(e,r),i=$f(void 0===n?r:n,r),a=Wf(Uf(i-o,0)),u=0;om;m++)if((u||m in v)&&(p=g(d=v[m],m,h),t))if(e)w[m]=p;else if(p)switch(t){case 3:return!0;case 5:return d;case 6:return m;case 2:op(w,d)}else switch(t){case 4:return!1;case 7:op(w,d)}return i?-1:r||o?o:w}},ap={forEach:ip(0),map:ip(1),filter:ip(2),some:ip(3),every:ip(4),find:ip(5),findIndex:ip(6),filterReject:ip(7)},up=y,cp=zd,sp=Od.getWeakData,lp=hi,fp=vt,dp=g,pp=rt,hp=es,vp=P,yp=sn.set,gp=sn.getterFor,mp=ap.find,bp=ap.findIndex,wp=up([].splice),Sp=0,Op=function(t){return t.frozen||(t.frozen=new jp)},jp=function(){this.entries=[]},Ep=function(t,e){return mp(t.entries,(function(t){return t[0]===e}))};jp.prototype={get:function(t){var e=Ep(this,t);if(e)return e[1]},has:function(t){return!!Ep(this,t)},set:function(t,e){var n=Ep(this,t);n?n[1]=e:this.entries.push([t,e])},delete:function(t){var e=bp(this.entries,(function(e){return e[0]===t}));return~e&&wp(this.entries,e,1),!!~e}};var Tp={getConstructor:function(t,e,n,r){var o=t((function(t,o){lp(t,i),yp(t,{type:e,id:Sp++,frozen:void 0}),dp(o)||hp(o,t[r],{that:t,AS_ENTRIES:n})})),i=o.prototype,a=gp(e),u=function(t,e,n){var r=a(t),o=sp(fp(e),!0);return!0===o?Op(r).set(e,n):o[r.id]=n,t};return cp(i,{delete:function(t){var e=a(this);if(!pp(t))return!1;var n=sp(t);return!0===n?Op(e).delete(t):n&&vp(n,e.id)&&delete n[e.id]},has:function(t){var e=a(this);if(!pp(t))return!1;var n=sp(t);return!0===n?Op(e).has(t):n&&vp(n,e.id)}}),cp(i,n?{get:function(t){var e=a(this);if(pp(t)){var n=sp(t);return!0===n?Op(e).get(t):n?n[e.id]:void 0}},set:function(t,e){return u(this,t,e)}}:{add:function(t){return u(this,t,!0)}}),o}};_d("WeakSet",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),Tp);var Pp={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0},xp=ct("span").classList,Rp=xp&&xp.constructor&&xp.constructor.prototype,Mp=Rp===Object.prototype?void 0:Rp,kp=F,Ap=Pp,Cp=Mp,Ip=vf,Lp=Ye,Np=ai,Bp=ye("iterator"),Dp=Ip.values,Gp=function(t,e){if(t){if(t[Bp]!==Dp)try{Lp(t,Bp,Dp)}catch(e){t[Bp]=Dp}if(Np(t,e,!0),Ap[e])for(var n in Ip)if(t[n]!==Ip[n])try{Lp(t,n,Ip[n])}catch(e){t[n]=Ip[n]}}};for(var Fp in Ap)Gp(kp[Fp]&&kp[Fp].prototype,Fp);Gp(Cp,"DOMTokenList");var qp=s,_p=kt,$p=ye("species"),zp=function(t){return _p>=51||!qp((function(){var e=[];return(e.constructor={})[$p]=function(){return{foo:1}},1!==e[t](Boolean).foo}))},Yp=mo,Wp=Wd,Up=Ci,Hp=rt,Vp=Er,Kp=Mr,Jp=er,Xp=_f,Qp=ye,Zp=Zi,th=zp("slice"),eh=Qp("species"),nh=Array,rh=Math.max;Yp({target:"Array",proto:!0,forced:!th},{slice:function(t,e){var n,r,o,i=Jp(this),a=Kp(i),u=Vp(t,a),c=Vp(void 0===e?a:e,a);if(Wp(i)&&(n=i.constructor,(Up(n)&&(n===nh||Wp(n.prototype))||Hp(n)&&null===(n=n[eh]))&&(n=void 0),n===nh||void 0===n))return Zp(i,u,c);for(r=new(void 0===n?nh:n)(rh(c-u,0)),o=0;u1?arguments[1]:void 0,e.length)),r=Th(t);return Mh?Mh(e,r,n):kh(e,n,n+r.length)===r}});var Ih=ap.forEach,Lh=ih("forEach")?[].forEach:function(t){return Ih(this,t,arguments.length>1?arguments[1]:void 0)},Nh=F,Bh=Pp,Dh=Mp,Gh=Lh,Fh=Ye,qh=function(t){if(t&&t.forEach!==Gh)try{Fh(t,"forEach",Gh)}catch(e){t.forEach=Gh}};for(var _h in Bh)Bh[_h]&&qh(Nh[_h]&&Nh[_h].prototype);qh(Dh);var $h=l,zh=s,Yh=y,Wh=wl,Uh=So,Hh=er,Vh=Yh(qn.f),Kh=Yh([].push),Jh=$h&&zh((function(){var t=Object.create(null);return t[2]=2,!Vh(t,2)})),Xh=function(t){return function(e){for(var n,r=Hh(e),o=Uh(r),i=Jh&&null===Wh(r),a=o.length,u=0,c=[];a>u;)n=o[u++],$h&&!(i?n in r:Vh(r,n))||Kh(c,t?[n,r[n]]:r[n]);return c}},Qh={entries:Xh(!0),values:Xh(!1)}.entries;function Zh(t){return null!=t&&!Number.isNaN(t)}function tv(t,n){return+Zh(n)-+Zh(t)||e.ascending(t,n)}function ev(t){return isFinite(t)?t:NaN}function nv(t){return t>0&&isFinite(t)?t:NaN}function rv(t){return t<0&&isFinite(t)?t:NaN}mo({target:"Object",stat:!0},{entries:function(t){return Qh(t)}});const ov=/^(?:[-+]\d{2})?\d{4}(?:-\d{2}(?:-\d{2})?)?(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d{3})?)?(?:Z|[-+]\d{2}:?\d{2})?)?$/;function iv(t,e){return ov.test(t+="")?new Date(t):"function"==typeof e?e(t):e}const av=new Map([["second",e.timeSecond],["minute",e.timeMinute],["hour",e.timeHour],["day",e.timeDay],["week",e.timeWeek],["month",e.timeMonth],["quarter",e.timeMonth.every(3)],["half",e.timeMonth.every(6)],["year",e.timeYear],["monday",e.timeMonday],["tuesday",e.timeTuesday],["wednesday",e.timeWednesday],["thursday",e.timeThursday],["friday",e.timeFriday],["saturday",e.timeSaturday],["sunday",e.timeSunday]]),uv=new Map([["second",e.utcSecond],["minute",e.utcMinute],["hour",e.utcHour],["day",e.utcDay],["week",e.utcWeek],["month",e.utcMonth],["quarter",e.utcMonth.every(3)],["half",e.utcMonth.every(6)],["year",e.utcYear],["monday",e.utcMonday],["tuesday",e.utcTuesday],["wednesday",e.utcWednesday],["thursday",e.utcThursday],["friday",e.utcFriday],["saturday",e.utcSaturday],["sunday",e.utcSunday]]);function cv(t){const e=av.get(`${t}`.toLowerCase());if(!e)throw new Error(`unknown interval: ${t}`);return e}function sv(t){const e=uv.get(`${t}`.toLowerCase());if(!e)throw new Error(`unknown interval: ${t}`);return e}const lv=Object.getPrototypeOf(Uint8Array),fv=Object.prototype.toString,dv=t=>()=>t;function pv(t){return t instanceof lv?t:mv(t,hv,Float64Array)}function hv(t){return null==t?NaN:Number(t)}function vv(t){return mv(t,yv)}function yv(t){return t instanceof Date&&!isNaN(t)?t:"string"==typeof t?iv(t):null==t||isNaN(t=+t)?void 0:new Date(t)}function gv(t){return null==t||t instanceof Array||t instanceof lv?t:Array.from(t)}function mv(t,e,n=Array){return null==t?t:t instanceof n?t.map(e):n.from(t,e)}function bv(t,e=Array){return t instanceof e?t.slice():e.from(t)}function wv(t){return function(t){return t?.toString===fv}(t)&&(void 0!==t.type||void 0!==t.domain)}function Sv(t,n){if(null!=t){if("number"==typeof t){0Math.floor(t*n)/n,offset:t=>(t*n+1)/n,range:(t,r)=>e.range(Math.ceil(t*n),r*n).map((t=>t/n))}:{floor:t=>Math.floor(t/n)*n,offset:t=>t+n,range:(t,r)=>e.range(Math.ceil(t/n),r/n).map((t=>t*n))}}if("string"==typeof t)return("time"===n?cv:sv)(t);if("function"!=typeof t.floor)throw new Error("invalid interval; missing floor method");if("function"!=typeof t.offset)throw new Error("invalid interval; missing offset method");return t}}function Ov(t,e){if((t=Sv(t,e))&&"function"!=typeof t.range)throw new Error("invalid interval: missing range method");return t}function jv(t){for(const e of t){if(null==e)continue;const t=typeof e;return"string"===t||"boolean"===t}}function Ev(t){for(const e of t)if(null!=e)return e instanceof Date}function Tv(t){for(const e of t)if(null!=e)return"string"==typeof e&&isNaN(e)&&iv(e)}function Pv(t){for(const e of t)if(null!=e){if("string"!=typeof e)return!1;if(e.trim())return!isNaN(e)}}function xv(t){if(null==t)return;const n=t[0],r=t[t.length-1];return e.descending(n,r)}const Rv=Symbol("position"),Mv=Symbol("color"),kv=Symbol("radius"),Av=Symbol("length"),Cv=Symbol("opacity"),Iv=Symbol("symbol"),Lv=new Map([["x",Rv],["y",Rv],["fx",Rv],["fy",Rv],["r",kv],["color",Mv],["opacity",Cv],["symbol",Iv],["length",Av]]),Nv=2/Math.sqrt(3),Bv={draw(t,e){const n=Math.sqrt(e/Math.PI),r=n*Nv,o=r/2;t.moveTo(0,r),t.lineTo(n,o),t.lineTo(n,-o),t.lineTo(0,-r),t.lineTo(-n,-o),t.lineTo(-n,o),t.closePath()}},Dv=new Map([["asterisk",e.symbolAsterisk],["circle",e.symbolCircle],["cross",e.symbolCross],["diamond",e.symbolDiamond],["diamond2",e.symbolDiamond2],["hexagon",Bv],["plus",e.symbolPlus],["square",e.symbolSquare],["square2",e.symbolSquare2],["star",e.symbolStar],["times",e.symbolTimes],["triangle",e.symbolTriangle],["triangle2",e.symbolTriangle2],["wye",e.symbolWye]]);function Gv(t){if(null==t||function(t){return t&&"function"==typeof t.draw}(t))return t;const e=Dv.get(`${t}`.toLowerCase());if(e)return e;throw new Error(`invalid symbol: ${t}`)}function Fv(t){console.warn(t)}const qv=new Map([["accent",e.schemeAccent],["category10",e.schemeCategory10],["dark2",e.schemeDark2],["paired",e.schemePaired],["pastel1",e.schemePastel1],["pastel2",e.schemePastel2],["set1",e.schemeSet1],["set2",e.schemeSet2],["set3",e.schemeSet3],["tableau10",e.schemeTableau10],["brbg",$v(e.schemeBrBG,e.interpolateBrBG)],["prgn",$v(e.schemePRGn,e.interpolatePRGn)],["piyg",$v(e.schemePiYG,e.interpolatePiYG)],["puor",$v(e.schemePuOr,e.interpolatePuOr)],["rdbu",$v(e.schemeRdBu,e.interpolateRdBu)],["rdgy",$v(e.schemeRdGy,e.interpolateRdGy)],["rdylbu",$v(e.schemeRdYlBu,e.interpolateRdYlBu)],["rdylgn",$v(e.schemeRdYlGn,e.interpolateRdYlGn)],["spectral",$v(e.schemeSpectral,e.interpolateSpectral)],["burd",zv(e.schemeRdBu,e.interpolateRdBu)],["buylrd",zv(e.schemeRdYlBu,e.interpolateRdYlBu)],["blues",_v(e.schemeBlues,e.interpolateBlues)],["greens",_v(e.schemeGreens,e.interpolateGreens)],["greys",_v(e.schemeGreys,e.interpolateGreys)],["oranges",_v(e.schemeOranges,e.interpolateOranges)],["purples",_v(e.schemePurples,e.interpolatePurples)],["reds",_v(e.schemeReds,e.interpolateReds)],["turbo",Yv(e.interpolateTurbo)],["viridis",Yv(e.interpolateViridis)],["magma",Yv(e.interpolateMagma)],["inferno",Yv(e.interpolateInferno)],["plasma",Yv(e.interpolatePlasma)],["cividis",Yv(e.interpolateCividis)],["cubehelix",Yv(e.interpolateCubehelixDefault)],["warm",Yv(e.interpolateWarm)],["cool",Yv(e.interpolateCool)],["bugn",_v(e.schemeBuGn,e.interpolateBuGn)],["bupu",_v(e.schemeBuPu,e.interpolateBuPu)],["gnbu",_v(e.schemeGnBu,e.interpolateGnBu)],["orrd",_v(e.schemeOrRd,e.interpolateOrRd)],["pubu",_v(e.schemePuBu,e.interpolatePuBu)],["pubugn",_v(e.schemePuBuGn,e.interpolatePuBuGn)],["purd",_v(e.schemePuRd,e.interpolatePuRd)],["rdpu",_v(e.schemeRdPu,e.interpolateRdPu)],["ylgn",_v(e.schemeYlGn,e.interpolateYlGn)],["ylgnbu",_v(e.schemeYlGnBu,e.interpolateYlGnBu)],["ylorbr",_v(e.schemeYlOrBr,e.interpolateYlOrBr)],["ylorrd",_v(e.schemeYlOrRd,e.interpolateYlOrRd)],["rainbow",Wv(e.interpolateRainbow)],["sinebow",Wv(e.interpolateSinebow)]]);function _v(t,n){return({length:r})=>1===r?[t[3][1]]:2===r?[t[3][1],t[3][2]]:(r=Math.max(3,Math.floor(r)))>9?e.quantize(n,r):t[r]}function $v(t,n){return({length:r})=>2===r?[t[3][0],t[3][2]]:(r=Math.max(3,Math.floor(r)))>11?e.quantize(n,r):t[r]}function zv(t,n){return({length:r})=>2===r?[t[3][2],t[3][0]]:(r=Math.max(3,Math.floor(r)))>11?e.quantize((t=>n(1-t)),r):t[r].slice().reverse()}function Yv(t){return({length:n})=>e.quantize(t,Math.max(2,Math.floor(n)))}function Wv(t){return({length:n})=>e.quantize(t,Math.floor(n)+1).slice(0,-1)}function Uv(t){const e=`${t}`.toLowerCase();if(!qv.has(e))throw new Error(`unknown ordinal scheme: ${e}`);return qv.get(e)}function Hv(t,e){const n=Uv(t),r="function"==typeof n?n({length:e}):n;return r.length!==e?r.slice(0,e):r}const Vv=new Map([["brbg",e.interpolateBrBG],["prgn",e.interpolatePRGn],["piyg",e.interpolatePiYG],["puor",e.interpolatePuOr],["rdbu",e.interpolateRdBu],["rdgy",e.interpolateRdGy],["rdylbu",e.interpolateRdYlBu],["rdylgn",e.interpolateRdYlGn],["spectral",e.interpolateSpectral],["burd",t=>e.interpolateRdBu(1-t)],["buylrd",t=>e.interpolateRdYlBu(1-t)],["blues",e.interpolateBlues],["greens",e.interpolateGreens],["greys",e.interpolateGreys],["purples",e.interpolatePurples],["reds",e.interpolateReds],["oranges",e.interpolateOranges],["turbo",e.interpolateTurbo],["viridis",e.interpolateViridis],["magma",e.interpolateMagma],["inferno",e.interpolateInferno],["plasma",e.interpolatePlasma],["cividis",e.interpolateCividis],["cubehelix",e.interpolateCubehelixDefault],["warm",e.interpolateWarm],["cool",e.interpolateCool],["bugn",e.interpolateBuGn],["bupu",e.interpolateBuPu],["gnbu",e.interpolateGnBu],["orrd",e.interpolateOrRd],["pubugn",e.interpolatePuBuGn],["pubu",e.interpolatePuBu],["purd",e.interpolatePuRd],["rdpu",e.interpolateRdPu],["ylgnbu",e.interpolateYlGnBu],["ylgn",e.interpolateYlGn],["ylorbr",e.interpolateYlOrBr],["ylorrd",e.interpolateYlOrRd],["rainbow",e.interpolateRainbow],["sinebow",e.interpolateSinebow]]);function Kv(t){const e=`${t}`.toLowerCase();if(!Vv.has(e))throw new Error(`unknown quantitative scheme: ${e}`);return Vv.get(e)}const Jv=new Set(["brbg","prgn","piyg","puor","rdbu","rdgy","rdylbu","rdylgn","spectral","burd","buylrd"]);function Xv(t){return null!=t&&Jv.has(`${t}`.toLowerCase())}const Qv=t=>e=>t(1-e),Zv=[0,1],ty=new Map([["number",e.interpolateNumber],["rgb",e.interpolateRgb],["hsl",e.interpolateHsl],["hcl",e.interpolateHcl],["lab",e.interpolateLab]]);function ey(t){const e=`${t}`.toLowerCase();if(!ty.has(e))throw new Error(`unknown interpolator: ${e}`);return ty.get(e)}function ny(t,n,r,{type:o,nice:i,clamp:a,zero:u,domain:c=ay(t,r),unknown:s,round:l,scheme:f,interval:d,range:p=(Lv.get(t)===kv?cy(r,c):Lv.get(t)===Av?sy(r,c):Lv.get(t)===Cv?Zv:void 0),interpolate:h=(Lv.get(t)===Mv?null==f&&void 0!==p?e.interpolateRgb:Kv(void 0!==f?f:"cyclical"===o?"rainbow":"turbo"):l?e.interpolateRound:e.interpolateNumber),reverse:v}){if(d=Ov(d,o),"cyclical"!==o&&"sequential"!==o||(o="linear"),v=!!v,"function"!=typeof h&&(h=ey(h)),1===h.length?(v&&(h=Qv(h),v=!1),void 0===p&&2===(p=Float64Array.from(c,((t,e)=>e/(c.length-1)))).length&&(p=Zv),n.interpolate((p===Zv?dv:dy)(h))):n.interpolate(h),u){const[t,n]=e.extent(c);(t>0||n<0)&&(xv(c=bv(c))!==Math.sign(t)?c[c.length-1]=0:c[0]=0)}return v&&(c=e.reverse(c)),n.domain(c).unknown(s),i&&(n.nice(function(t,e){return!0===t?void 0:"number"==typeof t?t:function(t,e){if((t=Ov(t,e))&&"function"!=typeof t.ceil)throw new Error("invalid interval: missing ceil method");return t}(t,e)}(i,o)),c=n.domain()),void 0!==p&&n.range(p),a&&n.clamp(a),{type:o,domain:c,range:p,scale:n,interpolate:h,interval:d}}function ry(t,n,{exponent:r=1,...o}){return ny(t,e.scalePow().exponent(r),n,{...o,type:"pow"})}function oy(t,n,{domain:r=[0],unknown:o,scheme:i="rdylbu",interpolate:a,range:u=(void 0!==a?e.quantize(a,r.length+1):Lv.get(t)===Mv?Hv(i,r.length+1):void 0),reverse:c}){const s=xv(r=gv(r));if(!isNaN(s)&&!function(t,n){for(let r=1,o=t.length,i=t[0];rvoid 0===t?t:e.min(t,n))),e.max(t,(({value:t})=>void 0===t?t:e.max(t,n)))]:[0,1]}function ay(t,e){const n=Lv.get(t);return(n===kv||n===Cv||n===Av?uy:iy)(e)}function uy(t){return[0,t.length?e.max(t,(({value:t})=>void 0===t?t:e.max(t,ev))):1]}function cy(t,n){const r=t.find((({radius:t})=>void 0!==t));if(void 0!==r)return[0,r.radius];const o=e.quantile(t,.5,(({value:t})=>void 0===t?NaN:e.quantile(t,.25,nv))),i=n.map((t=>3*Math.sqrt(t/o))),a=30/e.max(i);return a<1?i.map((t=>t*a)):i}function sy(t,n){const r=e.median(t,(({value:t})=>void 0===t?NaN:e.median(t,Math.abs))),o=n.map((t=>12*t/r)),i=60/e.max(o);return i<1?o.map((t=>t*i)):o}function ly(t){for(const{value:e}of t)if(void 0!==e)for(let n of e){if(n>0)return iy(t,nv);if(n<0)return iy(t,rv)}return[1,10]}function fy(t){const e=[];for(const{value:n}of t)if(void 0!==n)for(const t of n)e.push(t);return e}function dy(t){return(e,n)=>r=>t(e+r*(n-e))}function py(t,n,r,o,{type:i,nice:a,clamp:u,domain:c=iy(o),unknown:s,pivot:l=0,scheme:f,range:d,symmetric:p=!0,interpolate:h=(Lv.get(t)===Mv?null==f&&void 0!==d?e.interpolateRgb:Kv(void 0!==f?f:"rdbu"):e.interpolateNumber),reverse:v}){l=+l;let[y,g]=c;if(e.descending(y,g)<0&&([y,g]=[g,y],v=!v),y=Math.min(y,l),g=Math.max(g,l),"function"!=typeof h&&(h=ey(h)),void 0!==d&&(h=1===h.length?dy(h)(...d):e.piecewise(h,d)),v&&(h=Qv(h)),p){const t=r.apply(l),e=t-r.apply(y),n=r.apply(g)-t;en&&(g=r.invert(t+e))}return n.domain([y,l,g]).unknown(s).interpolator(h),u&&n.clamp(u),a&&n.nice(a),{type:i,domain:[y,g],pivot:l,interpolate:h,scale:n}}function hy(t,n,{exponent:r=1,...o}){return py(t,e.scaleDivergingPow().exponent(r=+r),function(t){return.5===t?my:{apply:e=>Math.sign(e)*Math.pow(Math.abs(e),t),invert:e=>Math.sign(e)*Math.pow(Math.abs(e),1/t)}}(r),n,{...o,type:"diverging-pow"})}function vy(t,n,{constant:r=1,...o}){return py(t,e.scaleDivergingSymlog().constant(r=+r),function(t){return{apply:e=>Math.sign(e)*Math.log1p(Math.abs(e/t)),invert:e=>Math.sign(e)*Math.expm1(Math.abs(e))*t}}(r),n,o)}const yy={apply:t=>t,invert:t=>t},gy={apply:Math.log,invert:Math.exp},my={apply:t=>Math.sign(t)*Math.sqrt(Math.abs(t)),invert:t=>Math.sign(t)*(t*t)};function by(t,e,n,r){return ny(t,e,n,r)}const wy=Symbol("ordinal");function Sy(t,n,r,{type:o,interval:i,domain:a,range:u,reverse:c,hint:s}){return i=Ov(i,o),void 0===a&&(a=Ey(r,i,t)),"categorical"!==o&&o!==wy||(o="ordinal"),c&&(a=e.reverse(a)),n.domain(a),void 0!==u&&("function"==typeof u&&(u=u(a)),n.range(u)),{type:o,domain:a,range:u,scale:n,hint:s,interval:i}}function Oy(t,n,{type:r,interval:o,domain:i,range:a,scheme:u,unknown:c,...s}){let l;if(o=Ov(o,r),void 0===i&&(i=Ey(n,o,t)),Lv.get(t)===Iv)l=function(t){return{fill:Ty(t,"fill"),stroke:Ty(t,"stroke")}}(n),a=void 0===a?function(t){return n=t.fill,null==n||function(t){return/^\s*none\s*$/i.test(t)}(n)?e.symbolsStroke:e.symbolsFill;var n}(l):mv(a,Gv);else if(Lv.get(t)===Mv&&(void 0!==a||"ordinal"!==r&&r!==wy||(a=function(t,e="greys"){const n=new Set,[r,o]=Hv(e,2);for(const e of t)if(null!=e)if(!0===e)n.add(o);else{if(!1!==e)return;n.add(r)}return[...n]}(i,u),void 0!==a&&(u=void 0)),void 0===u&&void 0===a&&(u="ordinal"===r?"turbo":"tableau10"),void 0!==u))if(void 0!==a){const t=Kv(u),n=a[0],r=a[1]-a[0];a=({length:o})=>e.quantize((e=>t(n+r*e)),o)}else a=Uv(u);if(c===e.scaleImplicit)throw new Error(`implicit unknown on ${t} scale is not supported`);return Sy(t,e.scaleOrdinal().unknown(c),n,{...s,type:r,domain:i,range:a,hint:l})}function jy(t,e,n,r){let{round:o}=n;return void 0!==o&&t.round(o=!!o),(t=Sy(r,t,e,n)).round=o,t}function Ey(t,n,r){const o=new e.InternSet;for(const{value:e,domain:n}of t){if(void 0!==n)return n();if(void 0!==e)for(const t of e)o.add(t)}if(void 0!==n){const[t,r]=e.extent(o).map(n.floor,n);return n.range(t,n.offset(r))}if(o.size>1e4&&Lv.get(r)===Rv)throw new Error(`implicit ordinal domain of ${r} scale has more than 10,000 values`);return e.sort(o,tv)}function Ty(t,e){let n;for(const{hint:r}of t){const t=r?.[e];if(void 0!==t)if(void 0===n)n=t;else if(n!==t)return}return n}function Py(t,n,r){return function(t,n=[],r={}){const o=function(t,e,{type:n,domain:r,range:o,scheme:i,pivot:a,projection:u}){if("fx"===t||"fy"===t)return"band";"x"!==t&&"y"!==t||null==u||(n=Ry);for(const{type:t}of e)if(void 0!==t)if(void 0===n)n=t;else if(n!==t)throw new Error(`scale incompatible with channel: ${n} !== ${t}`);if(n===Ry)return;if(void 0!==n)return n;if(void 0===r&&!e.some((({value:t})=>void 0!==t)))return;const c=Lv.get(t);if(c===kv)return"sqrt";if(c===Cv||c===Av)return"linear";if(c===Iv)return"ordinal";if((r||o||[]).length>2)return My(c);if(void 0!==r)return jv(r)?My(c):Ev(r)?"utc":c!==Mv||null==a&&!Xv(i)?"linear":"diverging";const s=e.map((({value:t})=>t)).filter((t=>void 0!==t));return s.some(jv)?My(c):s.some(Ev)?"utc":c!==Mv||null==a&&!Xv(i)?"linear":"diverging"}(t,n,r);if(void 0===r.type&&void 0===r.domain&&void 0===r.range&&null==r.interval&&"fx"!==t&&"fy"!==t&&function({type:t}){return"ordinal"===t||"point"===t||"band"===t||t===wy}({type:o})){const e=n.map((({value:t})=>t)).filter((t=>void 0!==t));e.some(Ev)?Fv(`Warning: some data associated with the ${t} scale are dates. Dates are typically associated with a "utc" or "time" scale rather than a "${xy(o)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${t} scale to "${xy(o)}".`):e.some(Tv)?Fv(`Warning: some data associated with the ${t} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a "utc" or "time" scale rather than a "${xy(o)}" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${t} scale to "${xy(o)}".`):e.some(Pv)&&Fv(`Warning: some data associated with the ${t} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a "linear" scale rather than a "${xy(o)}" scale. If you want to treat this data as ordinal, you can specify the interval of the ${t} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${t} scale to "${xy(o)}".`)}switch(r.type=o,o){case"diverging":case"diverging-sqrt":case"diverging-pow":case"diverging-log":case"diverging-symlog":case"cyclical":case"sequential":case"linear":case"sqrt":case"threshold":case"quantile":case"pow":case"log":case"symlog":r=ky(n,r,pv);break;case"identity":switch(Lv.get(t)){case Rv:r=ky(n,r,pv);break;case Iv:r=ky(n,r,Ay)}break;case"utc":case"time":r=ky(n,r,vv)}switch(o){case"diverging":return function(t,n,r){return py(t,e.scaleDiverging(),yy,n,r)}(t,n,r);case"diverging-sqrt":return function(t,e,n){return hy(t,e,{...n,exponent:.5})}(t,n,r);case"diverging-pow":return hy(t,n,r);case"diverging-log":return function(t,n,{base:r=10,pivot:o=1,domain:i=iy(n,o<0?rv:nv),...a}){return py(t,e.scaleDivergingLog().base(r=+r),gy,n,{domain:i,pivot:o,...a})}(t,n,r);case"diverging-symlog":return vy(t,n,r);case"categorical":case"ordinal":case wy:return Oy(t,n,r);case"cyclical":case"sequential":case"linear":return function(t,n,r){return ny(t,e.scaleLinear(),n,r)}(t,n,r);case"sqrt":return function(t,e,n){return ry(t,e,{...n,exponent:.5})}(t,n,r);case"threshold":return oy(t,0,r);case"quantile":return function(t,n,{range:r,quantiles:o=(void 0===r?5:(r=[...r]).length),n:i=o,scheme:a="rdylbu",domain:u=fy(n),unknown:c,interpolate:s,reverse:l}){return void 0===r&&(r=void 0!==s?e.quantize(s,i):Lv.get(t)===Mv?Hv(a,i):void 0),u.length>0&&(u=e.scaleQuantile(u,void 0===r?{length:i}:r).quantiles()),oy(t,0,{domain:u,range:r,reverse:l,unknown:c})}(t,n,r);case"quantize":return function(t,n,{range:r,n:o=(void 0===r?5:(r=[...r]).length),scheme:i="rdylbu",domain:a=ay(t,n),unknown:u,interpolate:c,reverse:s}){const[l,f]=e.extent(a);let d;return void 0===r?(d=e.ticks(l,f,o),d[0]<=l&&d.splice(0,1),d[d.length-1]>=f&&d.pop(),o=d.length+1,r=void 0!==c?e.quantize(c,o):Lv.get(t)===Mv?Hv(i,o):void 0):(d=e.quantize(e.interpolateNumber(l,f),o+1).slice(1,-1),l instanceof Date&&(d=d.map((t=>new Date(t))))),xv(gv(a))<0&&d.reverse(),oy(t,0,{domain:d,range:r,reverse:s,unknown:u})}(t,n,r);case"pow":return ry(t,n,r);case"log":return function(t,n,{base:r=10,domain:o=ly(n),...i}){return ny(t,e.scaleLog().base(r),n,{...i,domain:o})}(t,n,r);case"symlog":return function(t,n,{constant:r=1,...o}){return ny(t,e.scaleSymlog().constant(r),n,o)}(t,n,r);case"utc":return function(t,n,r){return by(t,e.scaleUtc(),n,r)}(t,n,r);case"time":return function(t,n,r){return by(t,e.scaleTime(),n,r)}(t,n,r);case"point":return function(t,n,{align:r=.5,padding:o=.5,...i}){return jy(e.scalePoint().align(r).padding(o),n,i,t)}(t,n,r);case"band":return function(t,n,{align:r=.5,padding:o=.1,paddingInner:i=o,paddingOuter:a=("fx"===t||"fy"===t?0:o),...u}){return jy(e.scaleBand().align(r).paddingInner(i).paddingOuter(a),n,u,t)}(t,n,r);case"identity":return Lv.get(t)===Rv?{type:"identity",scale:e.scaleIdentity()}:{type:"identity"};case void 0:return;default:throw new Error(`unknown scale type: ${o}`)}}(t,void 0===r?void 0:[{hint:r}],{...n})}function xy(t){return"symbol"==typeof t?t.description:t}const Ry={toString:()=>"projection"};function My(t){switch(t){case Rv:return"point";case Mv:return wy;default:return"ordinal"}}function ky(t,{domain:e,...n},r){for(const e of t)void 0!==e.value&&(e.value=r(e.value));return{domain:void 0===e?e:r(e),...n}}function Ay(t){return mv(t,Gv)}function Cy({scale:t,type:e,domain:n,range:r,interpolate:o,interval:i,transform:a,percent:u,pivot:c}){if("identity"===e)return{type:"identity",apply:t=>t,invert:t=>t};const s=t.unknown?t.unknown():void 0;return{type:e,domain:bv(n),...void 0!==r&&{range:bv(r)},...void 0!==a&&{transform:a},...u&&{percent:u},...void 0!==s&&{unknown:s},...void 0!==i&&{interval:i},...void 0!==o&&{interpolate:o},...t.clamp&&{clamp:t.clamp()},...void 0!==c&&{pivot:c,symmetric:!1},...t.base&&{base:t.base()},...t.exponent&&{exponent:t.exponent()},...t.constant&&{constant:t.constant()},...t.align&&{align:t.align(),round:t.round()},...t.padding&&(t.paddingInner?{paddingInner:t.paddingInner(),paddingOuter:t.paddingOuter()}:{padding:t.padding()}),...t.bandwidth&&{bandwidth:t.bandwidth(),step:t.step()},apply:e=>t(e),...t.invert&&{invert:e=>t.invert(e)}}}var Iy,Ly;!function(t){t[t.SCROLL_NONE=0]="SCROLL_NONE",t[t.SCROLL_BACKWARD=1]="SCROLL_BACKWARD",t[t.SCROLL_FORWARD=2]="SCROLL_FORWARD"}(Iy||(Iy={})),function(t){t[t.TOP=0]="TOP",t[t.RIGHT=1]="RIGHT",t[t.BOTTOM=2]="BOTTOM",t[t.LEFT=3]="LEFT"}(Ly||(Ly={}));var Ny="red";function By(t){try{var e=Object.keys(t)[0];return function(t={}){let e;for(const n in t)if(Lv.has(n)&&wv(t[n])){if(void 0!==e)throw new Error("ambiguous scale definition; multiple scales found");e=Cy(Py(n,t[n]))}if(void 0===e)throw new Error("invalid scale definition; no scale found");return e}((n={},r=e,o=Object.assign(Object.assign({},t[e]),{clamp:!0}),(r=u(r))in n?Object.defineProperty(n,r,{value:o,enumerable:!0,configurable:!0,writable:!0}):n[r]=o,n))}catch(t){return null}var n,r,o}function Dy(t,e,n,o){Object.entries(function(t,e){var n={};return e.hasOwnProperty("opacity")?(n.fill=function(){return e.opacity.baseColor||Ny},n["fill-opacity"]=function(e){return null==t?void 0:t.apply(e)}):n.fill=function(e){return"string"==typeof e&&(null==e?void 0:e.startsWith("#"))?e:null==t?void 0:t.apply(e)},n}(e,n)).forEach((function(e){var n=r(e,2),i=n[0],a=n[1];return t.style(i,(function(t){return a(o?t[o]:t)}))}))}var Gy=TypeError,Fy=mo,qy=s,_y=Wd,$y=rt,zy=j,Yy=Mr,Wy=function(t){if(t>9007199254740991)throw Gy("Maximum allowed index exceeded");return t},Uy=_f,Hy=Qd,Vy=zp,Ky=kt,Jy=ye("isConcatSpreadable"),Xy=Ky>=51||!qy((function(){var t=[];return t[Jy]=!1,t.concat()[0]!==t})),Qy=function(t){if(!$y(t))return!1;var e=t[Jy];return void 0!==e?!!e:_y(t)};Fy({target:"Array",proto:!0,arity:1,forced:!Xy||!Vy("concat")},{concat:function(t){var e,n,r,o,i,a=zy(this),u=Hy(a,0),c=0;for(e=-1,r=arguments.length;e1?arguments[1]:void 0);e=e?e.next:n.first;)for(r(e.value,e.key,this);e&&e.removed;)e=e.previous},has:function(t){return!!c(this,t)}}),ag(i,n?{get:function(t){var e=c(this,t);return e&&e.value},set:function(t,e){return u(this,0===t?0:t,e)}}:{add:function(t){return u(this,t=0===t?0:t,t)}}),hg&&ig(i,"size",{configurable:!0,get:function(){return a(this).size}}),o},setStrong:function(t,e,n){var r=e+" Iterator",o=gg(e),i=gg(r);fg(t,e,(function(t,e){yg(this,{type:r,target:t,state:o(t),kind:e,last:void 0})}),(function(){for(var t=i(this),e=t.kind,n=t.last;n&&n.removed;)n=n.previous;return t.target&&(t.last=n=n?n.next:t.state.first)?dg("keys"===e?n.key:"values"===e?n.value:[n.key,n.value],!1):(t.target=void 0,dg(void 0,!0))}),n?"entries":"values",!n,!0),pg(e)}};_d("Map",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),mg);var bg=$t,wg=TypeError,Sg=Hf,Og=Math.floor,jg=function(t,e){var n=t.length,r=Og(n/2);return n<8?Eg(t,e):Tg(t,jg(Sg(t,0,r),e),jg(Sg(t,r),e),e)},Eg=function(t,e){for(var n,r,o=t.length,i=1;i0;)t[r]=t[--r];r!==i++&&(t[r]=n)}return t},Tg=function(t,e,n,r){for(var o=e.length,i=n.length,a=0,u=0;a3)){if(zg)return!0;if(Wg)return Wg<603;var t,e,n,r,o="";for(t=65;t<76;t++){switch(e=String.fromCharCode(t),t){case 66:case 69:case 70:case 72:n=3;break;case 68:case 71:n=4;break;default:n=2}for(r=0;r<47;r++)Ug.push({k:e+r,v:n})}for(Ug.sort((function(t,e){return e.v-t.v})),r=0;rGg(n)?1:-1}}(t)),n=Bg(o),r=0;r1?arguments[1]:void 0)}}),tm("includes");var em=ap.map;mo({target:"Array",proto:!0,forced:!zp("map")},{map:function(t){return em(this,t,arguments.length>1?arguments[1]:void 0)}});var nm=ap.filter;mo({target:"Array",proto:!0,forced:!zp("filter")},{filter:function(t){return nm(this,t,arguments.length>1?arguments[1]:void 0)}});var rm=vt,om=_c,im=Xi,am=mt,um=j,cm=function(t,e,n,r){try{return r?e(rm(n)[0],n[1]):e(n)}catch(e){om(t,"throw",e)}},sm=Ec,lm=Ci,fm=Mr,dm=_f,pm=Dc,hm=kc,vm=Array,ym=function(t){var e=um(t),n=lm(this),r=arguments.length,o=r>1?arguments[1]:void 0,i=void 0!==o;i&&(o=im(o,r>2?arguments[2]:void 0));var a,u,c,s,l,f,d=hm(e),p=0;if(!d||this===vm&&sm(d))for(a=fm(e),u=n?new this(a):vm(a);a>p;p++)f=i?o(e[p],p):e[p],dm(u,p,f);else for(l=(s=pm(e,d)).next,u=n?new this:[];!(c=am(l,s)).done;p++)f=i?cm(s,o,[c.value,p],!0):c.value,dm(u,p,f);return u.length=p,u};mo({target:"Array",stat:!0,forced:!as((function(t){Array.from(t)}))},{from:ym});var gm="\t\n\v\f\r                　\u2028\u2029\ufeff",mm=w,bm=bf,wm=gm,Sm=y("".replace),Om=RegExp("^["+wm+"]+"),jm=RegExp("(^|[^"+wm+"])["+wm+"]+$"),Em=function(t){return function(e){var n=bm(mm(e));return 1&t&&(n=Sm(n,Om,"")),2&t&&(n=Sm(n,jm,"$1")),n}},Tm={start:Em(1),end:Em(2),trim:Em(3)},Pm=C.PROPER,xm=s,Rm=gm,Mm=Tm.trim;mo({target:"String",proto:!0,forced:function(t){return xm((function(){return!!Rm[t]()||"​…᠎"!=="​…᠎"[t]()||Pm&&Rm[t].name!==t}))}("trim")},{trim:function(){return Mm(this)}});var km,Am,Cm,Im=".ch-plugin-legend-lite",Lm={enabled:!0,itemSelector:null,width:10,height:10,gutter:2,radius:0,includeBlank:!1},Nm=function(){function e(t){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,e),km.add(this),this.name="LegendLite",this.calendar=t,this.root=null,this.shown=!1,this.options=Lm}var r,o,i;return r=e,o=[{key:"setup",value:function(t){this.options=Object.assign(Object.assign({},this.options),t)}},{key:"paint",value:function(){var e=this.options,n=e.enabled,r=e.itemSelector;if(!n||r&&t.select(r).empty())return this.destroy();this.shown=!0,this.root=t.select(r||this.calendar.options.options.itemSelector),this.root.select(Im).empty()?this.root=this.root.append("div").attr("class",Im.slice(1)):this.root=this.root.select(Im);var o=fh(this,km,"m",Am).call(this);return this.root.selectAll("*").remove(),this.root.append((function(){return o.node()})),Promise.resolve()}},{key:"destroy",value:function(){return null!==this.root&&(this.root.remove(),this.root=null),Promise.resolve()}}],o&&n(r.prototype,o),i&&n(r,i),Object.defineProperty(r,"prototype",{writable:!1}),e}();return km=new WeakSet,Am=function(){var e=this,n=t.create("svg"),r=By(this.calendar.options.options.scale),i=this.options,a=i.width,u=i.height,c=i.gutter,s=i.includeBlank,l=o(r.range);return s&&l.unshift(null),n.attr("class",".ch-container".slice(1)).attr("width",l.length*a+(l.length-1)*c).attr("height",u),n.selectAll("rect").data(l).join((function(t){return t.append("rect").call((function(t){return fh(e,km,"m",Cm).call(e,t,r)}))}),(function(t){return t.selectAll("rect").call((function(t){return fh(e,km,"m",Cm).call(e,t,r)}))})),n},Cm=function(t,e){var n=this,r=this.options,o=r.width,i=r.height,a=r.radius,u=r.gutter;return t.attr("width",o).attr("height",i).attr("class","".concat(".ch-subdomain".slice(1),"-bg")).attr("rx",a).attr("ry",a).attr("x",(function(t,e){return e*(o+u)})).attr("y",0).call((function(t){Dy(t,e,n.calendar.options.options.scale)}))},Nm}));//# sourceMappingURL=LegendLite.min.js.map diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.js.map b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.js.map new file mode 100644 index 0000000..bde1490 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/LegendLite.min.js.map @@ -0,0 +1 @@ +{"version":3,"file":"LegendLite.min.js","sources":["../../node_modules/core-js/internals/fails.js","../../node_modules/core-js/internals/descriptors.js","../../node_modules/core-js/internals/function-bind-native.js","../../node_modules/core-js/internals/function-uncurry-this.js","../../node_modules/core-js/internals/is-null-or-undefined.js","../../node_modules/core-js/internals/require-object-coercible.js","../../node_modules/core-js/internals/to-object.js","../../node_modules/core-js/internals/has-own-property.js","../../node_modules/core-js/internals/function-name.js","../../node_modules/core-js/internals/document-all.js","../../node_modules/core-js/internals/is-callable.js","../../node_modules/core-js/internals/global.js","../../node_modules/core-js/internals/define-global-property.js","../../node_modules/core-js/internals/shared-store.js","../../node_modules/core-js/internals/inspect-source.js","../../node_modules/core-js/internals/engine-v8-version.js","../../node_modules/core-js/internals/weak-map-basic-detection.js","../../node_modules/core-js/internals/is-object.js","../../node_modules/core-js/internals/document-create-element.js","../../node_modules/core-js/internals/ie8-dom-define.js","../../node_modules/core-js/internals/v8-prototype-define-bug.js","../../node_modules/core-js/internals/an-object.js","../../node_modules/core-js/internals/function-call.js","../../node_modules/core-js/internals/get-built-in.js","../../node_modules/core-js/internals/object-is-prototype-of.js","../../node_modules/core-js/internals/engine-user-agent.js","../../node_modules/core-js/internals/symbol-constructor-detection.js","../../node_modules/core-js/internals/use-symbol-as-uid.js","../../node_modules/core-js/internals/is-symbol.js","../../node_modules/core-js/internals/try-to-string.js","../../node_modules/core-js/internals/a-callable.js","../../node_modules/core-js/internals/get-method.js","../../node_modules/core-js/internals/ordinary-to-primitive.js","../../node_modules/core-js/internals/shared.js","../../node_modules/core-js/internals/uid.js","../../node_modules/core-js/internals/well-known-symbol.js","../../node_modules/core-js/internals/to-primitive.js","../../node_modules/core-js/internals/to-property-key.js","../../node_modules/core-js/internals/object-define-property.js","../../node_modules/core-js/internals/create-property-descriptor.js","../../node_modules/core-js/internals/internal-state.js","../../node_modules/core-js/internals/create-non-enumerable-property.js","../../node_modules/core-js/internals/shared-key.js","../../node_modules/core-js/internals/hidden-keys.js","../../node_modules/core-js/internals/make-built-in.js","../../node_modules/core-js/internals/define-built-in-accessor.js","../../node_modules/core-js/modules/es.function.name.js","../../node_modules/core-js/internals/object-property-is-enumerable.js","../../node_modules/core-js/internals/classof-raw.js","../../node_modules/core-js/internals/indexed-object.js","../../node_modules/core-js/internals/to-indexed-object.js","../../node_modules/core-js/internals/object-get-own-property-descriptor.js","../../node_modules/core-js/internals/define-built-in.js","../../node_modules/core-js/internals/math-trunc.js","../../node_modules/core-js/internals/to-integer-or-infinity.js","../../node_modules/core-js/internals/to-absolute-index.js","../../node_modules/core-js/internals/to-length.js","../../node_modules/core-js/internals/length-of-array-like.js","../../node_modules/core-js/internals/array-includes.js","../../node_modules/core-js/internals/object-keys-internal.js","../../node_modules/core-js/internals/enum-bug-keys.js","../../node_modules/core-js/internals/object-get-own-property-names.js","../../node_modules/core-js/internals/object-get-own-property-symbols.js","../../node_modules/core-js/internals/own-keys.js","../../node_modules/core-js/internals/copy-constructor-properties.js","../../node_modules/core-js/internals/is-forced.js","../../node_modules/core-js/internals/export.js","../../node_modules/core-js/internals/object-keys.js","../../node_modules/core-js/internals/object-assign.js","../../node_modules/core-js/modules/es.object.assign.js","../../node_modules/core-js/internals/to-string-tag-support.js","../../node_modules/core-js/internals/classof.js","../../node_modules/core-js/internals/object-to-string.js","../../node_modules/core-js/modules/es.object.to-string.js","../../node_modules/core-js/internals/engine-is-node.js","../../node_modules/core-js/internals/function-uncurry-this-accessor.js","../../node_modules/core-js/internals/a-possible-prototype.js","../../node_modules/core-js/internals/object-set-prototype-of.js","../../node_modules/core-js/internals/set-to-string-tag.js","../../node_modules/core-js/internals/set-species.js","../../node_modules/core-js/internals/an-instance.js","../../node_modules/core-js/internals/is-constructor.js","../../node_modules/core-js/internals/task.js","../../node_modules/core-js/internals/a-constructor.js","../../node_modules/core-js/internals/species-constructor.js","../../node_modules/core-js/internals/function-apply.js","../../node_modules/core-js/internals/function-uncurry-this-clause.js","../../node_modules/core-js/internals/function-bind-context.js","../../node_modules/core-js/internals/html.js","../../node_modules/core-js/internals/array-slice.js","../../node_modules/core-js/internals/validate-arguments-length.js","../../node_modules/core-js/internals/engine-is-ios.js","../../node_modules/core-js/internals/queue.js","../../node_modules/core-js/internals/microtask.js","../../node_modules/core-js/internals/engine-is-ios-pebble.js","../../node_modules/core-js/internals/engine-is-webos-webkit.js","../../node_modules/core-js/internals/perform.js","../../node_modules/core-js/internals/promise-native-constructor.js","../../node_modules/core-js/internals/engine-is-deno.js","../../node_modules/core-js/internals/engine-is-browser.js","../../node_modules/core-js/internals/promise-constructor-detection.js","../../node_modules/core-js/internals/new-promise-capability.js","../../node_modules/core-js/modules/es.promise.constructor.js","../../node_modules/core-js/internals/host-report-errors.js","../../node_modules/core-js/internals/iterators.js","../../node_modules/core-js/internals/is-array-iterator-method.js","../../node_modules/core-js/internals/get-iterator-method.js","../../node_modules/core-js/internals/get-iterator.js","../../node_modules/core-js/internals/iterator-close.js","../../node_modules/core-js/internals/iterate.js","../../node_modules/core-js/internals/check-correctness-of-iteration.js","../../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","../../node_modules/core-js/modules/es.promise.all.js","../../node_modules/core-js/modules/es.promise.catch.js","../../node_modules/core-js/modules/es.promise.race.js","../../node_modules/core-js/modules/es.promise.reject.js","../../node_modules/core-js/internals/promise-resolve.js","../../node_modules/core-js/modules/es.promise.resolve.js","../../node_modules/core-js/internals/object-define-properties.js","../../node_modules/core-js/internals/object-create.js","../../node_modules/core-js/internals/add-to-unscopables.js","../../node_modules/core-js/internals/iterators-core.js","../../node_modules/core-js/internals/correct-prototype-getter.js","../../node_modules/core-js/internals/object-get-prototype-of.js","../../node_modules/core-js/internals/iterator-create-constructor.js","../../node_modules/core-js/internals/iterator-define.js","../../node_modules/core-js/internals/create-iter-result-object.js","../../node_modules/core-js/modules/es.array.iterator.js","../../node_modules/core-js/internals/to-string.js","../../node_modules/core-js/internals/string-multibyte.js","../../node_modules/core-js/modules/es.string.iterator.js","../../node_modules/core-js/internals/create-property.js","../../node_modules/core-js/internals/array-slice-simple.js","../../node_modules/core-js/internals/object-get-own-property-names-external.js","../../node_modules/core-js/internals/array-buffer-non-extensible.js","../../node_modules/core-js/internals/object-is-extensible.js","../../node_modules/core-js/internals/freezing.js","../../node_modules/core-js/internals/internal-metadata.js","../../node_modules/core-js/internals/inherit-if-required.js","../../node_modules/core-js/internals/collection.js","../../node_modules/core-js/internals/define-built-ins.js","../../node_modules/core-js/internals/is-array.js","../../node_modules/core-js/internals/array-species-constructor.js","../../node_modules/core-js/internals/array-species-create.js","../../node_modules/core-js/internals/array-iteration.js","../../node_modules/core-js/internals/collection-weak.js","../../node_modules/core-js/modules/es.weak-set.constructor.js","../../node_modules/core-js/internals/dom-iterables.js","../../node_modules/core-js/internals/dom-token-list-prototype.js","../../node_modules/core-js/modules/web.dom-collections.iterator.js","../../node_modules/core-js/internals/array-method-has-species-support.js","../../node_modules/core-js/modules/es.array.slice.js","../../node_modules/core-js/internals/array-method-is-strict.js","../../node_modules/core-js/modules/es.array.join.js","../../node_modules/tslib/tslib.es6.js","../../node_modules/core-js/modules/es.object.keys.js","../../node_modules/core-js/internals/is-regexp.js","../../node_modules/core-js/modules/es.string.starts-with.js","../../node_modules/core-js/internals/not-a-regexp.js","../../node_modules/core-js/internals/correct-is-regexp-logic.js","../../node_modules/core-js/internals/array-for-each.js","../../node_modules/core-js/modules/web.dom-collections.for-each.js","../../node_modules/core-js/internals/object-to-array.js","../../node_modules/core-js/modules/es.object.entries.js","../../node_modules/@observablehq/plot/src/defined.js","../../node_modules/isoformat/src/parse.js","../../node_modules/@observablehq/plot/src/time.js","../../node_modules/@observablehq/plot/src/options.js","../../node_modules/@observablehq/plot/src/scales/index.js","../../node_modules/@observablehq/plot/src/symbol.js","../../node_modules/@observablehq/plot/src/warnings.js","../../node_modules/@observablehq/plot/src/scales/schemes.js","../../node_modules/@observablehq/plot/src/scales/quantitative.js","../../node_modules/@observablehq/plot/src/scales/diverging.js","../../node_modules/@observablehq/plot/src/scales/temporal.js","../../node_modules/@observablehq/plot/src/scales/ordinal.js","../../node_modules/@observablehq/plot/src/scales.js","../../../src/constant.ts","../../../src/scale.ts","../../node_modules/core-js/internals/does-not-exceed-safe-integer.js","../../node_modules/core-js/modules/es.array.concat.js","../../node_modules/core-js/modules/es.promise.all-settled.js","../../node_modules/core-js/internals/collection-strong.js","../../node_modules/core-js/modules/es.map.constructor.js","../../node_modules/core-js/internals/delete-property-or-throw.js","../../node_modules/core-js/internals/array-sort.js","../../node_modules/core-js/internals/engine-ff-version.js","../../node_modules/core-js/internals/engine-is-ie-or-edge.js","../../node_modules/core-js/internals/engine-webkit-version.js","../../node_modules/core-js/modules/es.array.sort.js","../../node_modules/core-js/modules/es.array.includes.js","../../node_modules/core-js/modules/es.array.map.js","../../node_modules/core-js/modules/es.array.filter.js","../../node_modules/core-js/internals/call-with-safe-iteration-closing.js","../../node_modules/core-js/internals/array-from.js","../../node_modules/core-js/modules/es.array.from.js","../../node_modules/core-js/internals/whitespaces.js","../../node_modules/core-js/internals/string-trim.js","../../node_modules/core-js/internals/string-trim-forced.js","../../node_modules/core-js/modules/es.string.trim.js","../../../src/subDomain/SubDomainPainter.ts","../../../src/plugins/LegendLite.ts","../../../src/calendar/CalendarPainter.ts"],"sourcesContent":["'use strict';\nmodule.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-function-prototype-bind -- safe\n var test = (function () { /* empty */ }).bind();\n // eslint-disable-next-line no-prototype-builtins -- safe\n return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n return function () {\n return call.apply(fn, arguments);\n };\n};\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n return it === null || it === undefined;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n return it;\n};\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar documentAll = typeof document == 'object' && document.all;\n\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nvar IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;\n\nmodule.exports = {\n all: documentAll,\n IS_HTMLDDA: IS_HTMLDDA\n};\n","'use strict';\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = $documentAll.IS_HTMLDDA ? function (argument) {\n return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n return typeof argument == 'function';\n};\n","'use strict';\nvar check = function (it) {\n return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n check(typeof this == 'object' && this) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\nmodule.exports = $documentAll.IS_HTMLDDA ? function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;\n} : function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a !== 7;\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype !== 42;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol('symbol detection');\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n // of course, fail.\n return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n try {\n return $String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.34.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',\n license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',\n source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name)) {\n WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n ? Symbol[name]\n : createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw new $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","'use strict';\nmodule.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n /* eslint-disable no-self-assign -- prototype methods protection */\n store.get = store.get;\n store.has = store.has;\n store.set = store.set;\n /* eslint-enable no-self-assign -- prototype methods protection */\n set = function (it, metadata) {\n if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n store.set(it, metadata);\n return metadata;\n };\n get = function (it) {\n return store.get(it) || {};\n };\n has = function (it) {\n return store.has(it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (options && options.getter) name = 'get ' + name;\n if (options && options.setter) name = 'set ' + name;\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n else value.name = name;\n }\n if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n defineProperty(value, 'length', { value: options.arity });\n }\n try {\n if (options && hasOwn(options, 'constructor') && options.constructor) {\n if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n } else if (value.prototype) value.prototype = undefined;\n } catch (error) { /* empty */ }\n var state = enforceInternalState(value);\n if (!hasOwn(state, 'source')) {\n state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineProperty = require('../internals/object-define-property');\n\nmodule.exports = function (target, name, descriptor) {\n if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });\n if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });\n return defineProperty.f(target, name, descriptor);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar FUNCTION_NAME_EXISTS = require('../internals/function-name').EXISTS;\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\n\nvar FunctionPrototype = Function.prototype;\nvar functionToString = uncurryThis(FunctionPrototype.toString);\nvar nameRE = /function\\b(?:\\s|\\/\\*[\\S\\s]*?\\*\\/|\\/\\/[^\\n\\r]*[\\n\\r]+)*([^\\s(/]*)/;\nvar regExpExec = uncurryThis(nameRE.exec);\nvar NAME = 'name';\n\n// Function instances `.name` property\n// https://tc39.es/ecma262/#sec-function-instances-name\nif (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {\n defineBuiltInAccessor(FunctionPrototype, NAME, {\n configurable: true,\n get: function () {\n try {\n return regExpExec(nameRE, functionToString(this))[1];\n } catch (error) {\n return '';\n }\n }\n });\n}\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- NaN check\n return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el !== el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value !== value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value === POLYFILL ? true\n : value === NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.dontCallGetSet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || defineGlobalProperty(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.dontCallGetSet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n defineBuiltIn(target, key, sourceProperty, options);\n }\n};\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol('assign detection');\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","'use strict';\nvar $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {\n assign: assign\n});\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar global = require('../internals/global');\nvar classof = require('../internals/classof-raw');\n\nmodule.exports = classof(global.process) === 'process';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nmodule.exports = function (object, key, method) {\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));\n } catch (error) { /* empty */ }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw new $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","'use strict';\n/* eslint-disable no-proto -- safe */\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (target, TAG, STATIC) {\n if (target && !STATIC) target = target.prototype;\n if (target && !hasOwn(target, TO_STRING_TAG)) {\n defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineBuiltInAccessor(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw new $TypeError('Incorrect invocation');\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.test(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n }\n try {\n // we can't check .prototype since constructors produced by .bind haven't it\n // `Function#toString` throws on some built-it function in some legacy engines\n // (for example, `DOMQuad` and similar in FF41-)\n return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n } catch (error) {\n return true;\n }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar $location, defer, channel, port;\n\nfails(function () {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n $location = global.location;\n});\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar eventListener = function (event) {\n run(event.data);\n};\n\nvar globalPostMessageDefer = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), $location.protocol + '//' + $location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(handler) {\n validateArgumentsLength(arguments.length, 1);\n var fn = isCallable(handler) ? handler : Function(handler);\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(fn, undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = eventListener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n $location && $location.protocol !== 'file:' &&\n !fails(globalPostMessageDefer)\n ) {\n defer = globalPostMessageDefer;\n global.addEventListener('message', eventListener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","'use strict';\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a constructor');\n};\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","'use strict';\nvar classofRaw = require('../internals/classof-raw');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (fn) {\n // Nashorn bug:\n // https://github.com/zloirock/core-js/issues/1128\n // https://github.com/zloirock/core-js/issues/1130\n if (classofRaw(fn) === 'Function') return uncurryThis(fn);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","'use strict';\nvar $TypeError = TypeError;\n\nmodule.exports = function (passed, required) {\n if (passed < required) throw new $TypeError('Not enough arguments');\n return passed;\n};\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line redos/no-vulnerable -- safe\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","'use strict';\nvar Queue = function () {\n this.head = null;\n this.tail = null;\n};\n\nQueue.prototype = {\n add: function (item) {\n var entry = { item: item, next: null };\n var tail = this.tail;\n if (tail) tail.next = entry;\n else this.head = entry;\n this.tail = entry;\n },\n get: function () {\n var entry = this.head;\n if (entry) {\n var next = this.head = entry.next;\n if (next === null) this.tail = null;\n return entry.item;\n }\n }\n};\n\nmodule.exports = Queue;\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar Queue = require('../internals/queue');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar microtask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\nvar notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!microtask) {\n var queue = new Queue();\n\n var flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (fn = queue.get()) try {\n fn();\n } catch (error) {\n if (queue.head) notify();\n throw error;\n }\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessage\n // - onreadystatechange\n // - setTimeout\n } else {\n // `webpack` dev server bug on IE global methods - use bind(fn, global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n\n microtask = function (fn) {\n if (!queue.head) notify();\n queue.add(fn);\n };\n}\n\nmodule.exports = microtask;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","'use strict';\nvar global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n && typeof window == 'object'\n && typeof document == 'object';\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n // Detect correctness of subclassing with @@species support\n var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar $TypeError = TypeError;\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar IS_NODE = require('../internals/engine-is-node');\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar perform = require('../internals/perform');\nvar Queue = require('../internals/queue');\nvar InternalStateModule = require('../internals/internal-state');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar PromiseConstructorDetection = require('../internals/promise-constructor-detection');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\n\nvar PROMISE = 'Promise';\nvar FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;\nvar NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;\nvar NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar PromiseConstructor = NativePromiseConstructor;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar callReaction = function (reaction, state) {\n var value = state.value;\n var ok = state.state === FULFILLED;\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(new TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n microtask(function () {\n var reactions = state.reactions;\n var reaction;\n while (reaction = reactions.get()) {\n callReaction(reaction, state);\n }\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw new TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED_PROMISE_CONSTRUCTOR) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalPromiseState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n\n PromisePrototype = PromiseConstructor.prototype;\n\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: new Queue(),\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n state.parent = true;\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n if (state.state === PENDING) state.reactions.add(reaction);\n else microtask(function () {\n callReaction(reaction, state);\n });\n return reaction.promise;\n });\n\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalPromiseState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!NATIVE_PROMISE_SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n","'use strict';\nmodule.exports = function (a, b) {\n try {\n // eslint-disable-next-line no-console -- safe\n arguments.length === 1 ? console.error(a) : console.error(a, b);\n } catch (error) { /* empty */ }\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw new $TypeError(tryToString(argument) + ' is not iterable');\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_RECORD = !!(options && options.IS_RECORD);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_RECORD) {\n iterator = iterable.iterator;\n } else if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = IS_RECORD ? iterable.next : iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n try {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n } catch (error) { return false; } // workaround of old WebKit + `eval` bug\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.all` method\n// https://tc39.es/ecma262/#sec-promise.all\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar defineBuiltIn = require('../internals/define-built-in');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\n\n// `Promise.prototype.catch` method\n// https://tc39.es/ecma262/#sec-promise.prototype.catch\n$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n});\n\n// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromiseConstructor)) {\n var method = getBuiltIn('Promise').prototype['catch'];\n if (NativePromisePrototype['catch'] !== method) {\n defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.race` method\n// https://tc39.es/ecma262/#sec-promise.race\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\n// `Promise.reject` method\n// https://tc39.es/ecma262/#sec-promise.reject\n$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n reject: function reject(r) {\n var capability = newPromiseCapabilityModule.f(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar promiseResolve = require('../internals/promise-resolve');\n\nvar PromiseConstructorWrapper = getBuiltIn('Promise');\nvar CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;\n\n// `Promise.resolve` method\n// https://tc39.es/ecma262/#sec-promise.resolve\n$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {\n resolve: function resolve(x) {\n return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);\n }\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var props = toIndexedObject(Properties);\n var keys = objectKeys(Properties);\n var length = keys.length;\n var index = 0;\n var key;\n while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n return O;\n};\n","'use strict';\n/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n activeXDocument.write(scriptTag(''));\n activeXDocument.close();\n var temp = activeXDocument.parentWindow.Object;\n activeXDocument = null; // avoid memory leak\n return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = documentCreateElement('iframe');\n var JS = 'java' + SCRIPT + ':';\n var iframeDocument;\n iframe.style.display = 'none';\n html.appendChild(iframe);\n // https://github.com/zloirock/core-js/issues/475\n iframe.src = String(JS);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(scriptTag('document.F=Object'));\n iframeDocument.close();\n return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n try {\n activeXDocument = new ActiveXObject('htmlfile');\n } catch (error) { /* ignore */ }\n NullProtoObject = typeof document != 'undefined'\n ? document.domain && activeXDocument\n ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n : NullProtoObjectViaIFrame()\n : NullProtoObjectViaActiveX(activeXDocument); // WSH\n var length = enumBugKeys.length;\n while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n EmptyConstructor[PROTOTYPE] = anObject(O);\n result = new EmptyConstructor();\n EmptyConstructor[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = NullProtoObject();\n return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] === undefined) {\n defineProperty(ArrayPrototype, UNSCOPABLES, {\n configurable: true,\n value: create(null)\n });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n arrayIterator = [].keys();\n // Safari 8 has buggy iterators w/o `next`\n if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n else {\n PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {\n var test = {};\n // FF44- legacy iterators case\n return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n defineBuiltIn(IteratorPrototype, ITERATOR, function () {\n return this;\n });\n}\n\nmodule.exports = {\n IteratorPrototype: IteratorPrototype,\n BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n function F() { /* empty */ }\n F.prototype.constructor = null;\n // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar $Object = Object;\nvar ObjectPrototype = $Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n// eslint-disable-next-line es/no-object-getprototypeof -- safe\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {\n var object = toObject(O);\n if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n var constructor = object.constructor;\n if (isCallable(constructor) && object instanceof constructor) {\n return constructor.prototype;\n } return object instanceof $Object ? ObjectPrototype : null;\n};\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {\n var TO_STRING_TAG = NAME + ' Iterator';\n IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });\n setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n Iterators[TO_STRING_TAG] = returnThis;\n return IteratorConstructor;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/iterator-create-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n createIteratorConstructor(IteratorConstructor, NAME, next);\n\n var getIterationMethod = function (KIND) {\n if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];\n\n switch (KIND) {\n case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n }\n\n return function () { return new IteratorConstructor(this); };\n };\n\n var TO_STRING_TAG = NAME + ' Iterator';\n var INCORRECT_VALUES_NAME = false;\n var IterablePrototype = Iterable.prototype;\n var nativeIterator = IterablePrototype[ITERATOR]\n || IterablePrototype['@@iterator']\n || DEFAULT && IterablePrototype[DEFAULT];\n var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n var CurrentIteratorPrototype, methods, KEY;\n\n // fix native\n if (anyNativeIterator) {\n CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n if (setPrototypeOf) {\n setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);\n }\n }\n // Set @@toStringTag to native iterators\n setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n }\n }\n\n // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n } else {\n INCORRECT_VALUES_NAME = true;\n defaultIterator = function values() { return call(nativeIterator, this); };\n }\n }\n\n // export additional methods\n if (DEFAULT) {\n methods = {\n values: getIterationMethod(VALUES),\n keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n entries: getIterationMethod(ENTRIES)\n };\n if (FORCED) for (KEY in methods) {\n if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n defineBuiltIn(IterablePrototype, KEY, methods[KEY]);\n }\n } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n }\n\n // define iterator\n if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n }\n Iterators[NAME] = defaultIterator;\n\n return methods;\n};\n","'use strict';\n// `CreateIterResultObject` abstract operation\n// https://tc39.es/ecma262/#sec-createiterresultobject\nmodule.exports = function (value, done) {\n return { value: value, done: done };\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineProperty = require('../internals/object-define-property').f;\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar IS_PURE = require('../internals/is-pure');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n setInternalState(this, {\n type: ARRAY_ITERATOR,\n target: toIndexedObject(iterated), // target\n index: 0, // next index\n kind: kind // kind\n });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n var state = getInternalState(this);\n var target = state.target;\n var index = state.index++;\n if (!target || index >= target.length) {\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n switch (state.kind) {\n case 'keys': return createIterResultObject(index, false);\n case 'values': return createIterResultObject(target[index], false);\n } return createIterResultObject([index, target[index]], false);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nvar values = Iterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n// V8 ~ Chrome 45- bug\nif (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {\n defineProperty(values, 'name', { value: 'values' });\n} catch (error) { /* empty */ }\n","'use strict';\nvar classof = require('../internals/classof');\n\nvar $String = String;\n\nmodule.exports = function (argument) {\n if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n return $String(argument);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n return function ($this, pos) {\n var S = toString(requireObjectCoercible($this));\n var position = toIntegerOrInfinity(pos);\n var size = S.length;\n var first, second;\n if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n first = charCodeAt(S, position);\n return first < 0xD800 || first > 0xDBFF || position + 1 === size\n || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n ? CONVERT_TO_STRING\n ? charAt(S, position)\n : first\n : CONVERT_TO_STRING\n ? stringSlice(S, position, position + 2)\n : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n };\n};\n\nmodule.exports = {\n // `String.prototype.codePointAt` method\n // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n codeAt: createMethod(false),\n // `String.prototype.at` method\n // https://github.com/mathiasbynens/String.prototype.at\n charAt: createMethod(true)\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n setInternalState(this, {\n type: STRING_ITERATOR,\n string: toString(iterated),\n index: 0\n });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n var state = getInternalState(this);\n var string = state.string;\n var index = state.index;\n var point;\n if (index >= string.length) return createIterResultObject(undefined, true);\n point = charAt(string, index);\n state.index += point.length;\n return createIterResultObject(point, false);\n});\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n var propertyKey = toPropertyKey(key);\n if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n else object[propertyKey] = value;\n};\n","'use strict';\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\n\nvar $Array = Array;\nvar max = Math.max;\n\nmodule.exports = function (O, start, end) {\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n var result = $Array(max(fin - k, 0));\n var n = 0;\n for (; k < fin; k++, n++) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n};\n","'use strict';\n/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n try {\n return $getOwnPropertyNames(it);\n } catch (error) {\n return arraySlice(windowNames);\n }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n return windowNames && classof(it) === 'Window'\n ? getWindowNames(it)\n : $getOwnPropertyNames(toIndexedObject(it));\n};\n","'use strict';\n// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it\nvar fails = require('../internals/fails');\n\nmodule.exports = fails(function () {\n if (typeof ArrayBuffer == 'function') {\n var buffer = new ArrayBuffer(8);\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe\n if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar ARRAY_BUFFER_NON_EXTENSIBLE = require('../internals/array-buffer-non-extensible');\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar $isExtensible = Object.isExtensible;\nvar FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); });\n\n// `Object.isExtensible` method\n// https://tc39.es/ecma262/#sec-object.isextensible\nmodule.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) {\n if (!isObject(it)) return false;\n if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false;\n return $isExtensible ? $isExtensible(it) : true;\n} : $isExtensible;\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n return Object.isExtensible(Object.preventExtensions({}));\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar isExtensible = require('../internals/object-is-extensible');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar setMetadata = function (it) {\n defineProperty(it, METADATA, { value: {\n objectID: 'O' + id++, // object ID\n weakData: {} // weak collections IDs\n } });\n};\n\nvar fastKey = function (it, create) {\n // return a primitive with prefix\n if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return 'F';\n // not necessary to add metadata\n if (!create) return 'E';\n // add missing metadata\n setMetadata(it);\n // return object ID\n } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return true;\n // not necessary to add metadata\n if (!create) return false;\n // add missing metadata\n setMetadata(it);\n // return the store of weak collections IDs\n } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n return it;\n};\n\nvar enable = function () {\n meta.enable = function () { /* empty */ };\n REQUIRED = true;\n var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n var splice = uncurryThis([].splice);\n var test = {};\n test[METADATA] = 1;\n\n // prevent exposing of metadata key\n if (getOwnPropertyNames(test).length) {\n getOwnPropertyNamesModule.f = function (it) {\n var result = getOwnPropertyNames(it);\n for (var i = 0, length = result.length; i < length; i++) {\n if (result[i] === METADATA) {\n splice(result, i, 1);\n break;\n }\n } return result;\n };\n\n $({ target: 'Object', stat: true, forced: true }, {\n getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n });\n }\n};\n\nvar meta = module.exports = {\n enable: enable,\n fastKey: fastKey,\n getWeakData: getWeakData,\n onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n var NewTarget, NewTargetPrototype;\n if (\n // it can work only with native `setPrototypeOf`\n setPrototypeOf &&\n // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n isCallable(NewTarget = dummy.constructor) &&\n NewTarget !== Wrapper &&\n isObject(NewTargetPrototype = NewTarget.prototype) &&\n NewTargetPrototype !== Wrapper.prototype\n ) setPrototypeOf($this, NewTargetPrototype);\n return $this;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n var ADDER = IS_MAP ? 'set' : 'add';\n var NativeConstructor = global[CONSTRUCTOR_NAME];\n var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n var Constructor = NativeConstructor;\n var exported = {};\n\n var fixMethod = function (KEY) {\n var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n defineBuiltIn(NativePrototype, KEY,\n KEY === 'add' ? function add(value) {\n uncurriedNativeMethod(this, value === 0 ? 0 : value);\n return this;\n } : KEY === 'delete' ? function (key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'get' ? function get(key) {\n return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'has' ? function has(key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : function set(key, value) {\n uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n return this;\n }\n );\n };\n\n var REPLACE = isForced(\n CONSTRUCTOR_NAME,\n !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n new NativeConstructor().entries().next();\n }))\n );\n\n if (REPLACE) {\n // create collection constructor\n Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n InternalMetadataModule.enable();\n } else if (isForced(CONSTRUCTOR_NAME, true)) {\n var instance = new Constructor();\n // early implementations not supports chaining\n var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance;\n // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n // most early implementations doesn't supports iterables, most modern - not close it correctly\n // eslint-disable-next-line no-new -- required for testing\n var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n // for early implementations -0 and +0 not the same\n var BUGGY_ZERO = !IS_WEAK && fails(function () {\n // V8 ~ Chromium 42- fails only with 5+ elements\n var $instance = new NativeConstructor();\n var index = 5;\n while (index--) $instance[ADDER](index, index);\n return !$instance.has(-0);\n });\n\n if (!ACCEPT_ITERABLES) {\n Constructor = wrapper(function (dummy, iterable) {\n anInstance(dummy, NativePrototype);\n var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n return that;\n });\n Constructor.prototype = NativePrototype;\n NativePrototype.constructor = Constructor;\n }\n\n if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n fixMethod('delete');\n fixMethod('has');\n IS_MAP && fixMethod('get');\n }\n\n if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n // weak collections should not contains .clear method\n if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n }\n\n exported[CONSTRUCTOR_NAME] = Constructor;\n $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported);\n\n setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n return Constructor;\n};\n","'use strict';\nvar defineBuiltIn = require('../internals/define-built-in');\n\nmodule.exports = function (target, src, options) {\n for (var key in src) defineBuiltIn(target, key, src[key], options);\n return target;\n};\n","'use strict';\nvar classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n return classof(argument) === 'Array';\n};\n","'use strict';\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n var C;\n if (isArray(originalArray)) {\n C = originalArray.constructor;\n // cross-realm fallback\n if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;\n else if (isObject(C)) {\n C = C[SPECIES];\n if (C === null) C = undefined;\n }\n } return C === undefined ? $Array : C;\n};\n","'use strict';\nvar arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n var IS_MAP = TYPE === 1;\n var IS_FILTER = TYPE === 2;\n var IS_SOME = TYPE === 3;\n var IS_EVERY = TYPE === 4;\n var IS_FIND_INDEX = TYPE === 6;\n var IS_FILTER_REJECT = TYPE === 7;\n var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;\n return function ($this, callbackfn, that, specificCreate) {\n var O = toObject($this);\n var self = IndexedObject(O);\n var length = lengthOfArrayLike(self);\n var boundFunction = bind(callbackfn, that);\n var index = 0;\n var create = specificCreate || arraySpeciesCreate;\n var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n var value, result;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n value = self[index];\n result = boundFunction(value, index, O);\n if (TYPE) {\n if (IS_MAP) target[index] = result; // map\n else if (result) switch (TYPE) {\n case 3: return true; // some\n case 5: return value; // find\n case 6: return index; // findIndex\n case 2: push(target, value); // filter\n } else switch (TYPE) {\n case 4: return false; // every\n case 7: push(target, value); // filterReject\n }\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.forEach` method\n // https://tc39.es/ecma262/#sec-array.prototype.foreach\n forEach: createMethod(0),\n // `Array.prototype.map` method\n // https://tc39.es/ecma262/#sec-array.prototype.map\n map: createMethod(1),\n // `Array.prototype.filter` method\n // https://tc39.es/ecma262/#sec-array.prototype.filter\n filter: createMethod(2),\n // `Array.prototype.some` method\n // https://tc39.es/ecma262/#sec-array.prototype.some\n some: createMethod(3),\n // `Array.prototype.every` method\n // https://tc39.es/ecma262/#sec-array.prototype.every\n every: createMethod(4),\n // `Array.prototype.find` method\n // https://tc39.es/ecma262/#sec-array.prototype.find\n find: createMethod(5),\n // `Array.prototype.findIndex` method\n // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n findIndex: createMethod(6),\n // `Array.prototype.filterReject` method\n // https://github.com/tc39/proposal-array-filtering\n filterReject: createMethod(7)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar getWeakData = require('../internals/internal-metadata').getWeakData;\nvar anInstance = require('../internals/an-instance');\nvar anObject = require('../internals/an-object');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar iterate = require('../internals/iterate');\nvar ArrayIterationModule = require('../internals/array-iteration');\nvar hasOwn = require('../internals/has-own-property');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\nvar find = ArrayIterationModule.find;\nvar findIndex = ArrayIterationModule.findIndex;\nvar splice = uncurryThis([].splice);\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (state) {\n return state.frozen || (state.frozen = new UncaughtFrozenStore());\n};\n\nvar UncaughtFrozenStore = function () {\n this.entries = [];\n};\n\nvar findUncaughtFrozen = function (store, key) {\n return find(store.entries, function (it) {\n return it[0] === key;\n });\n};\n\nUncaughtFrozenStore.prototype = {\n get: function (key) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) return entry[1];\n },\n has: function (key) {\n return !!findUncaughtFrozen(this, key);\n },\n set: function (key, value) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) entry[1] = value;\n else this.entries.push([key, value]);\n },\n 'delete': function (key) {\n var index = findIndex(this.entries, function (it) {\n return it[0] === key;\n });\n if (~index) splice(this.entries, index, 1);\n return !!~index;\n }\n};\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n id: id++,\n frozen: undefined\n });\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var data = getWeakData(anObject(key), true);\n if (data === true) uncaughtFrozenStore(state).set(key, value);\n else data[state.id] = value;\n return that;\n };\n\n defineBuiltIns(Prototype, {\n // `{ WeakMap, WeakSet }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.delete\n // https://tc39.es/ecma262/#sec-weakset.prototype.delete\n 'delete': function (key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state)['delete'](key);\n return data && hasOwn(data, state.id) && delete data[state.id];\n },\n // `{ WeakMap, WeakSet }.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.has\n // https://tc39.es/ecma262/#sec-weakset.prototype.has\n has: function has(key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).has(key);\n return data && hasOwn(data, state.id);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `WeakMap.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.get\n get: function get(key) {\n var state = getInternalState(this);\n if (isObject(key)) {\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).get(key);\n return data ? data[state.id] : undefined;\n }\n },\n // `WeakMap.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.set\n set: function set(key, value) {\n return define(this, key, value);\n }\n } : {\n // `WeakSet.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-weakset.prototype.add\n add: function add(value) {\n return define(this, value, true);\n }\n });\n\n return Constructor;\n }\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionWeak = require('../internals/collection-weak');\n\n// `WeakSet` constructor\n// https://tc39.es/ecma262/#sec-weakset-constructor\ncollection('WeakSet', function (init) {\n return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionWeak);\n","'use strict';\n// iterable DOM collections\n// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods\nmodule.exports = {\n CSSRuleList: 0,\n CSSStyleDeclaration: 0,\n CSSValueList: 0,\n ClientRectList: 0,\n DOMRectList: 0,\n DOMStringList: 0,\n DOMTokenList: 1,\n DataTransferItemList: 0,\n FileList: 0,\n HTMLAllCollection: 0,\n HTMLCollection: 0,\n HTMLFormElement: 0,\n HTMLSelectElement: 0,\n MediaList: 0,\n MimeTypeArray: 0,\n NamedNodeMap: 0,\n NodeList: 1,\n PaintRequestList: 0,\n Plugin: 0,\n PluginArray: 0,\n SVGLengthList: 0,\n SVGNumberList: 0,\n SVGPathSegList: 0,\n SVGPointList: 0,\n SVGStringList: 0,\n SVGTransformList: 0,\n SourceBufferList: 0,\n StyleSheetList: 0,\n TextTrackCueList: 0,\n TextTrackList: 0,\n TouchList: 0\n};\n","'use strict';\n// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`\nvar documentCreateElement = require('../internals/document-create-element');\n\nvar classList = documentCreateElement('span').classList;\nvar DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;\n\nmodule.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nvar handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {\n if (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n } catch (error) {\n CollectionPrototype[ITERATOR] = ArrayValues;\n }\n setToStringTag(CollectionPrototype, COLLECTION_NAME, true);\n if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n } catch (error) {\n CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n }\n }\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);\n}\n\nhandlePrototype(DOMTokenListPrototype, 'DOMTokenList');\n","'use strict';\nvar fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (METHOD_NAME) {\n // We can't use this feature detection in V8 since it causes\n // deoptimization and serious performance degradation\n // https://github.com/zloirock/core-js/issues/677\n return V8_VERSION >= 51 || !fails(function () {\n var array = [];\n var constructor = array.constructor = {};\n constructor[SPECIES] = function () {\n return { foo: 1 };\n };\n return array[METHOD_NAME](Boolean).foo !== 1;\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar createProperty = require('../internals/create-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar nativeSlice = require('../internals/array-slice');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('slice');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\nvar max = Math.max;\n\n// `Array.prototype.slice` method\n// https://tc39.es/ecma262/#sec-array.prototype.slice\n// fallback for not array-like ES3 strings and DOM objects\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n slice: function slice(start, end) {\n var O = toIndexedObject(this);\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n // inline `ArraySpeciesCreate` for usage native `Array#slice` where it's possible\n var Constructor, result, n;\n if (isArray(O)) {\n Constructor = O.constructor;\n // cross-realm fallback\n if (isConstructor(Constructor) && (Constructor === $Array || isArray(Constructor.prototype))) {\n Constructor = undefined;\n } else if (isObject(Constructor)) {\n Constructor = Constructor[SPECIES];\n if (Constructor === null) Constructor = undefined;\n }\n if (Constructor === $Array || Constructor === undefined) {\n return nativeSlice(O, k, fin);\n }\n }\n result = new (Constructor === undefined ? $Array : Constructor)(max(fin - k, 0));\n for (n = 0; k < fin; k++, n++) if (k in O) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = function (METHOD_NAME, argument) {\n var method = [][METHOD_NAME];\n return !!method && fails(function () {\n // eslint-disable-next-line no-useless-call -- required for testing\n method.call(null, argument || function () { return 1; }, 1);\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar nativeJoin = uncurryThis([].join);\n\nvar ES3_STRINGS = IndexedObject !== Object;\nvar FORCED = ES3_STRINGS || !arrayMethodIsStrict('join', ',');\n\n// `Array.prototype.join` method\n// https://tc39.es/ecma262/#sec-array.prototype.join\n$({ target: 'Array', proto: true, forced: FORCED }, {\n join: function join(separator) {\n return nativeJoin(toIndexedObject(this), separator === undefined ? ',' : separator);\n }\n});\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n var _, done = false;\r\n for (var i = decorators.length - 1; i >= 0; i--) {\r\n var context = {};\r\n for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n if (kind === \"accessor\") {\r\n if (result === void 0) continue;\r\n if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n if (_ = accept(result.get)) descriptor.get = _;\r\n if (_ = accept(result.set)) descriptor.set = _;\r\n if (_ = accept(result.init)) initializers.unshift(_);\r\n }\r\n else if (_ = accept(result)) {\r\n if (kind === \"field\") initializers.unshift(_);\r\n else descriptor[key] = _;\r\n }\r\n }\r\n if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n var useValue = arguments.length > 2;\r\n for (var i = 0; i < initializers.length; i++) {\r\n value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n }\r\n return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n 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;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n var desc = Object.getOwnPropertyDescriptor(m, k);\r\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n desc = { enumerable: true, get: function() { return m[k]; } };\r\n }\r\n Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport default {\r\n __extends,\r\n __assign,\r\n __rest,\r\n __decorate,\r\n __param,\r\n __metadata,\r\n __awaiter,\r\n __generator,\r\n __createBinding,\r\n __exportStar,\r\n __values,\r\n __read,\r\n __spread,\r\n __spreadArrays,\r\n __spreadArray,\r\n __await,\r\n __asyncGenerator,\r\n __asyncDelegator,\r\n __asyncValues,\r\n __makeTemplateObject,\r\n __importStar,\r\n __importDefault,\r\n __classPrivateFieldGet,\r\n __classPrivateFieldSet,\r\n __classPrivateFieldIn,\r\n};\r\n","'use strict';\nvar $ = require('../internals/export');\nvar toObject = require('../internals/to-object');\nvar nativeKeys = require('../internals/object-keys');\nvar fails = require('../internals/fails');\n\nvar FAILS_ON_PRIMITIVES = fails(function () { nativeKeys(1); });\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n$({ target: 'Object', stat: true, forced: FAILS_ON_PRIMITIVES }, {\n keys: function keys(it) {\n return nativeKeys(toObject(it));\n }\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\n// `IsRegExp` abstract operation\n// https://tc39.es/ecma262/#sec-isregexp\nmodule.exports = function (it) {\n var isRegExp;\n return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) === 'RegExp');\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar toLength = require('../internals/to-length');\nvar toString = require('../internals/to-string');\nvar notARegExp = require('../internals/not-a-regexp');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');\nvar IS_PURE = require('../internals/is-pure');\n\n// eslint-disable-next-line es/no-string-prototype-startswith -- safe\nvar nativeStartsWith = uncurryThis(''.startsWith);\nvar stringSlice = uncurryThis(''.slice);\nvar min = Math.min;\n\nvar CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');\n// https://github.com/zloirock/core-js/pull/702\nvar MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {\n var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith');\n return descriptor && !descriptor.writable;\n}();\n\n// `String.prototype.startsWith` method\n// https://tc39.es/ecma262/#sec-string.prototype.startswith\n$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {\n startsWith: function startsWith(searchString /* , position = 0 */) {\n var that = toString(requireObjectCoercible(this));\n notARegExp(searchString);\n var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));\n var search = toString(searchString);\n return nativeStartsWith\n ? nativeStartsWith(that, search, index)\n : stringSlice(that, index, index + search.length) === search;\n }\n});\n","'use strict';\nvar isRegExp = require('../internals/is-regexp');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it) {\n if (isRegExp(it)) {\n throw new $TypeError(\"The method doesn't accept regular expressions\");\n } return it;\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\nmodule.exports = function (METHOD_NAME) {\n var regexp = /./;\n try {\n '/./'[METHOD_NAME](regexp);\n } catch (error1) {\n try {\n regexp[MATCH] = false;\n return '/./'[METHOD_NAME](regexp);\n } catch (error2) { /* empty */ }\n } return false;\n};\n","'use strict';\nvar $forEach = require('../internals/array-iteration').forEach;\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\n\nvar STRICT_METHOD = arrayMethodIsStrict('forEach');\n\n// `Array.prototype.forEach` method implementation\n// https://tc39.es/ecma262/#sec-array.prototype.foreach\nmodule.exports = !STRICT_METHOD ? function forEach(callbackfn /* , thisArg */) {\n return $forEach(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n// eslint-disable-next-line es/no-array-prototype-foreach -- safe\n} : [].forEach;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar forEach = require('../internals/array-for-each');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nvar handlePrototype = function (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype && CollectionPrototype.forEach !== forEach) try {\n createNonEnumerableProperty(CollectionPrototype, 'forEach', forEach);\n } catch (error) {\n CollectionPrototype.forEach = forEach;\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n if (DOMIterables[COLLECTION_NAME]) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype);\n }\n}\n\nhandlePrototype(DOMTokenListPrototype);\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar objectGetPrototypeOf = require('../internals/object-get-prototype-of');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\nvar propertyIsEnumerable = uncurryThis($propertyIsEnumerable);\nvar push = uncurryThis([].push);\n\n// in some IE versions, `propertyIsEnumerable` returns incorrect result on integer keys\n// of `null` prototype objects\nvar IE_BUG = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-create -- safe\n var O = Object.create(null);\n O[2] = 2;\n return !propertyIsEnumerable(O, 2);\n});\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n return function (it) {\n var O = toIndexedObject(it);\n var keys = objectKeys(O);\n var IE_WORKAROUND = IE_BUG && objectGetPrototypeOf(O) === null;\n var length = keys.length;\n var i = 0;\n var result = [];\n var key;\n while (length > i) {\n key = keys[i++];\n if (!DESCRIPTORS || (IE_WORKAROUND ? key in O : propertyIsEnumerable(O, key))) {\n push(result, TO_ENTRIES ? [key, O[key]] : O[key]);\n }\n }\n return result;\n };\n};\n\nmodule.exports = {\n // `Object.entries` method\n // https://tc39.es/ecma262/#sec-object.entries\n entries: createMethod(true),\n // `Object.values` method\n // https://tc39.es/ecma262/#sec-object.values\n values: createMethod(false)\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $entries = require('../internals/object-to-array').entries;\n\n// `Object.entries` method\n// https://tc39.es/ecma262/#sec-object.entries\n$({ target: 'Object', stat: true }, {\n entries: function entries(O) {\n return $entries(O);\n }\n});\n","import {ascending, descending} from \"d3\";\n\nexport function defined(x) {\n return x != null && !Number.isNaN(x);\n}\n\nexport function ascendingDefined(a, b) {\n return +defined(b) - +defined(a) || ascending(a, b);\n}\n\nexport function descendingDefined(a, b) {\n return +defined(b) - +defined(a) || descending(a, b);\n}\n\nexport function nonempty(x) {\n return x != null && `${x}` !== \"\";\n}\n\nexport function finite(x) {\n return isFinite(x) ? x : NaN;\n}\n\nexport function positive(x) {\n return x > 0 && isFinite(x) ? x : NaN;\n}\n\nexport function negative(x) {\n return x < 0 && isFinite(x) ? x : NaN;\n}\n","const re = /^(?:[-+]\\d{2})?\\d{4}(?:-\\d{2}(?:-\\d{2})?)?(?:T\\d{2}:\\d{2}(?::\\d{2}(?:\\.\\d{3})?)?(?:Z|[-+]\\d{2}:?\\d{2})?)?$/;\n\nexport default function parse(string, fallback) {\n if (!re.test(string += \"\")) return typeof fallback === \"function\" ? fallback(string) : fallback;\n return new Date(string);\n}\n","import {utcSecond, utcMinute, utcHour, utcDay, utcWeek, utcMonth, utcYear} from \"d3\";\nimport {utcMonday, utcTuesday, utcWednesday, utcThursday, utcFriday, utcSaturday, utcSunday} from \"d3\";\nimport {timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear} from \"d3\";\nimport {timeMonday, timeTuesday, timeWednesday, timeThursday, timeFriday, timeSaturday, timeSunday} from \"d3\";\n\nconst timeIntervals = new Map([\n [\"second\", timeSecond],\n [\"minute\", timeMinute],\n [\"hour\", timeHour],\n [\"day\", timeDay],\n [\"week\", timeWeek],\n [\"month\", timeMonth],\n [\"quarter\", timeMonth.every(3)],\n [\"half\", timeMonth.every(6)],\n [\"year\", timeYear],\n [\"monday\", timeMonday],\n [\"tuesday\", timeTuesday],\n [\"wednesday\", timeWednesday],\n [\"thursday\", timeThursday],\n [\"friday\", timeFriday],\n [\"saturday\", timeSaturday],\n [\"sunday\", timeSunday]\n]);\n\nconst utcIntervals = new Map([\n [\"second\", utcSecond],\n [\"minute\", utcMinute],\n [\"hour\", utcHour],\n [\"day\", utcDay],\n [\"week\", utcWeek],\n [\"month\", utcMonth],\n [\"quarter\", utcMonth.every(3)],\n [\"half\", utcMonth.every(6)],\n [\"year\", utcYear],\n [\"monday\", utcMonday],\n [\"tuesday\", utcTuesday],\n [\"wednesday\", utcWednesday],\n [\"thursday\", utcThursday],\n [\"friday\", utcFriday],\n [\"saturday\", utcSaturday],\n [\"sunday\", utcSunday]\n]);\n\nexport function maybeTimeInterval(interval) {\n const i = timeIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n\nexport function maybeUtcInterval(interval) {\n const i = utcIntervals.get(`${interval}`.toLowerCase());\n if (!i) throw new Error(`unknown interval: ${interval}`);\n return i;\n}\n","import {parse as isoParse} from \"isoformat\";\nimport {color, descending, range as rangei, quantile} from \"d3\";\nimport {maybeTimeInterval, maybeUtcInterval} from \"./time.js\";\n\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray\nexport const TypedArray = Object.getPrototypeOf(Uint8Array);\nconst objectToString = Object.prototype.toString;\n\nexport function valueof(data, value, type) {\n const valueType = typeof value;\n return valueType === \"string\"\n ? maybeTypedMap(data, field(value), type)\n : valueType === \"function\"\n ? maybeTypedMap(data, value, type)\n : valueType === \"number\" || value instanceof Date || valueType === \"boolean\"\n ? map(data, constant(value), type)\n : typeof value?.transform === \"function\"\n ? maybeTypedArrayify(value.transform(data), type)\n : maybeTypedArrayify(value, type);\n}\n\nfunction maybeTypedMap(data, f, type) {\n return map(data, type?.prototype instanceof TypedArray ? floater(f) : f, type);\n}\n\nfunction maybeTypedArrayify(data, type) {\n return type === undefined\n ? arrayify(data) // preserve undefined type\n : data instanceof type\n ? data\n : type.prototype instanceof TypedArray && !(data instanceof TypedArray)\n ? type.from(data, coerceNumber)\n : type.from(data);\n}\n\nfunction floater(f) {\n return (d, i) => coerceNumber(f(d, i));\n}\n\nexport const field = (name) => (d) => d[name];\nexport const indexOf = {transform: range};\nexport const identity = {transform: (d) => d};\nexport const zero = () => 0;\nexport const one = () => 1;\nexport const yes = () => true;\nexport const string = (x) => (x == null ? x : `${x}`);\nexport const number = (x) => (x == null ? x : +x);\nexport const boolean = (x) => (x == null ? x : !!x);\nexport const first = (x) => (x ? x[0] : undefined);\nexport const second = (x) => (x ? x[1] : undefined);\nexport const third = (x) => (x ? x[2] : undefined);\nexport const constant = (x) => () => x;\n\n// Converts a string like “p25” into a function that takes an index I and an\n// accessor function f, returning the corresponding percentile value.\nexport function percentile(reduce) {\n const p = +`${reduce}`.slice(1) / 100;\n return (I, f) => quantile(I, p, f);\n}\n\n// If the values are specified as a typed array, no coercion is required.\nexport function coerceNumbers(values) {\n return values instanceof TypedArray ? values : map(values, coerceNumber, Float64Array);\n}\n\n// Unlike Mark’s number, here we want to convert null and undefined to NaN since\n// the result will be stored in a Float64Array and we don’t want null to be\n// coerced to zero. We use Number instead of unary + to allow BigInt coercion.\nfunction coerceNumber(x) {\n return x == null ? NaN : Number(x);\n}\n\nexport function coerceDates(values) {\n return map(values, coerceDate);\n}\n\n// When coercing strings to dates, we only want to allow the ISO 8601 format\n// since the built-in string parsing of the Date constructor varies across\n// browsers. (In the future, this could be made more liberal if desired, though\n// it is still generally preferable to do date parsing yourself explicitly,\n// rather than rely on Plot.) Any non-string values are coerced to number first\n// and treated as milliseconds since UNIX epoch.\nexport function coerceDate(x) {\n return x instanceof Date && !isNaN(x)\n ? x\n : typeof x === \"string\"\n ? isoParse(x)\n : x == null || isNaN((x = +x))\n ? undefined\n : new Date(x);\n}\n\n// Some channels may allow a string constant to be specified; to differentiate\n// string constants (e.g., \"red\") from named fields (e.g., \"date\"), this\n// function tests whether the given value is a CSS color string and returns a\n// tuple [channel, constant] where one of the two is undefined, and the other is\n// the given value. If you wish to reference a named field that is also a valid\n// CSS color, use an accessor (d => d.red) instead.\nexport function maybeColorChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null ? [undefined, \"none\"] : isColor(value) ? [undefined, value] : [value, undefined];\n}\n\n// Similar to maybeColorChannel, this tests whether the given value is a number\n// indicating a constant, and otherwise assumes that it’s a channel value.\nexport function maybeNumberChannel(value, defaultValue) {\n if (value === undefined) value = defaultValue;\n return value === null || typeof value === \"number\" ? [undefined, value] : [value, undefined];\n}\n\n// Validates the specified optional string against the allowed list of keywords.\nexport function maybeKeyword(input, name, allowed) {\n if (input != null) return keyword(input, name, allowed);\n}\n\n// Validates the specified required string against the allowed list of keywords.\nexport function keyword(input, name, allowed) {\n const i = `${input}`.toLowerCase();\n if (!allowed.includes(i)) throw new Error(`invalid ${name}: ${input}`);\n return i;\n}\n\n// Promotes the specified data to an array as needed.\nexport function arrayify(data) {\n return data == null || data instanceof Array || data instanceof TypedArray ? data : Array.from(data);\n}\n\n// An optimization of type.from(values, f): if the given values are already an\n// instanceof the desired array type, the faster values.map method is used.\nexport function map(values, f, type = Array) {\n return values == null ? values : values instanceof type ? values.map(f) : type.from(values, f);\n}\n\n// An optimization of type.from(values): if the given values are already an\n// instanceof the desired array type, the faster values.slice method is used.\nexport function slice(values, type = Array) {\n return values instanceof type ? values.slice() : type.from(values);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a primitive value.\nexport function isObject(option) {\n return option?.toString === objectToString;\n}\n\n// Disambiguates a scale options object (e.g., {color: {type: \"linear\"}}) from\n// some other option (e.g., {color: \"red\"}). When creating standalone legends,\n// this is used to test whether a scale is defined; this should be consistent\n// with inferScaleType when there are no channels associated with the scale, and\n// if this returns true, then normalizeScale must return non-null.\nexport function isScaleOptions(option) {\n return isObject(option) && (option.type !== undefined || option.domain !== undefined);\n}\n\n// Disambiguates an options object (e.g., {y: \"x2\"}) from a channel value\n// definition expressed as a channel transform (e.g., {transform: …}).\nexport function isOptions(option) {\n return isObject(option) && typeof option.transform !== \"function\";\n}\n\n// Disambiguates a sort transform (e.g., {sort: \"date\"}) from a channel domain\n// sort definition (e.g., {sort: {y: \"x\"}}).\nexport function isDomainSort(sort) {\n return isOptions(sort) && sort.value === undefined && sort.channel === undefined;\n}\n\n// For marks specified either as [0, x] or [x1, x2], such as areas and bars.\nexport function maybeZero(x, x1, x2, x3 = identity) {\n if (x1 === undefined && x2 === undefined) {\n // {x} or {}\n (x1 = 0), (x2 = x === undefined ? x3 : x);\n } else if (x1 === undefined) {\n // {x, x2} or {x2}\n x1 = x === undefined ? 0 : x;\n } else if (x2 === undefined) {\n // {x, x1} or {x1}\n x2 = x === undefined ? 0 : x;\n }\n return [x1, x2];\n}\n\n// For marks that have x and y channels (e.g., cell, dot, line, text).\nexport function maybeTuple(x, y) {\n return x === undefined && y === undefined ? [first, second] : [x, y];\n}\n\n// A helper for extracting the z channel, if it is variable. Used by transforms\n// that require series, such as moving average and normalize.\nexport function maybeZ({z, fill, stroke} = {}) {\n if (z === undefined) [z] = maybeColorChannel(fill);\n if (z === undefined) [z] = maybeColorChannel(stroke);\n return z;\n}\n\n// Returns a Uint32Array with elements [0, 1, 2, … data.length - 1].\nexport function range(data) {\n const n = data.length;\n const r = new Uint32Array(n);\n for (let i = 0; i < n; ++i) r[i] = i;\n return r;\n}\n\n// Returns a filtered range of data given the test function.\nexport function where(data, test) {\n return range(data).filter((i) => test(data[i], i, data));\n}\n\n// Returns an array [values[index[0]], values[index[1]], …].\nexport function take(values, index) {\n return map(index, (i) => values[i]);\n}\n\n// Based on InternMap (d3.group).\nexport function keyof(value) {\n return value !== null && typeof value === \"object\" ? value.valueOf() : value;\n}\n\nexport function maybeInput(key, options) {\n if (options[key] !== undefined) return options[key];\n switch (key) {\n case \"x1\":\n case \"x2\":\n key = \"x\";\n break;\n case \"y1\":\n case \"y2\":\n key = \"y\";\n break;\n }\n return options[key];\n}\n\nexport function column(source) {\n // Defines a column whose values are lazily populated by calling the returned\n // setter. If the given source is labeled, the label is propagated to the\n // returned column definition.\n let value;\n return [\n {\n transform: () => value,\n label: labelof(source)\n },\n (v) => (value = v)\n ];\n}\n\n// Like column, but allows the source to be null.\nexport function maybeColumn(source) {\n return source == null ? [source] : column(source);\n}\n\nexport function labelof(value, defaultValue) {\n return typeof value === \"string\" ? value : value && value.label !== undefined ? value.label : defaultValue;\n}\n\n// Assuming that both x1 and x2 and lazy columns (per above), this derives a new\n// a column that’s the average of the two, and which inherits the column label\n// (if any). Both input columns are assumed to be quantitative. If either column\n// is temporal, the returned column is also temporal.\nexport function mid(x1, x2) {\n return {\n transform(data) {\n const X1 = x1.transform(data);\n const X2 = x2.transform(data);\n return isTemporal(X1) || isTemporal(X2)\n ? map(X1, (_, i) => new Date((+X1[i] + +X2[i]) / 2))\n : map(X1, (_, i) => (+X1[i] + +X2[i]) / 2, Float64Array);\n },\n label: x1.label\n };\n}\n\n// If interval is not nullish, converts interval shorthand such as a number (for\n// multiples) or a time interval name (such as “day”) to a {floor, offset,\n// range} object similar to a D3 time interval.\nexport function maybeInterval(interval, type) {\n if (interval == null) return;\n if (typeof interval === \"number\") {\n if (0 < interval && interval < 1 && Number.isInteger(1 / interval)) interval = -1 / interval;\n const n = Math.abs(interval);\n return interval < 0\n ? {\n floor: (d) => Math.floor(d * n) / n,\n offset: (d) => (d * n + 1) / n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo * n), hi * n).map((x) => x / n)\n }\n : {\n floor: (d) => Math.floor(d / n) * n,\n offset: (d) => d + n, // note: no optional step for simplicity\n range: (lo, hi) => rangei(Math.ceil(lo / n), hi / n).map((x) => x * n)\n };\n }\n if (typeof interval === \"string\") return (type === \"time\" ? maybeTimeInterval : maybeUtcInterval)(interval);\n if (typeof interval.floor !== \"function\") throw new Error(\"invalid interval; missing floor method\");\n if (typeof interval.offset !== \"function\") throw new Error(\"invalid interval; missing offset method\");\n return interval;\n}\n\n// Like maybeInterval, but requires a range method too.\nexport function maybeRangeInterval(interval, type) {\n interval = maybeInterval(interval, type);\n if (interval && typeof interval.range !== \"function\") throw new Error(\"invalid interval: missing range method\");\n return interval;\n}\n\n// Like maybeRangeInterval, but requires a ceil method too.\nexport function maybeNiceInterval(interval, type) {\n interval = maybeRangeInterval(interval, type);\n if (interval && typeof interval.ceil !== \"function\") throw new Error(\"invalid interval: missing ceil method\");\n return interval;\n}\n\n// This distinguishes between per-dimension options and a standalone value.\nexport function maybeValue(value) {\n return value === undefined || isOptions(value) ? value : {value};\n}\n\n// Coerces the given channel values (if any) to numbers. This is useful when\n// values will be interpolated into other code, such as an SVG transform, and\n// where we don’t wish to allow unexpected behavior for weird input.\nexport function numberChannel(source) {\n return source == null\n ? null\n : {\n transform: (data) => valueof(data, source, Float64Array),\n label: labelof(source)\n };\n}\n\nexport function isTuples(data) {\n if (!isIterable(data)) return false;\n for (const d of data) {\n if (d == null) continue;\n return typeof d === \"object\" && \"0\" in d && \"1\" in d;\n }\n}\n\nexport function isIterable(value) {\n return value && typeof value[Symbol.iterator] === \"function\";\n}\n\nexport function isTextual(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value !== \"object\" || value instanceof Date;\n }\n}\n\nexport function isOrdinal(values) {\n for (const value of values) {\n if (value == null) continue;\n const type = typeof value;\n return type === \"string\" || type === \"boolean\";\n }\n}\n\nexport function isTemporal(values) {\n for (const value of values) {\n if (value == null) continue;\n return value instanceof Date;\n }\n}\n\n// Are these strings that might represent dates? This is stricter than ISO 8601\n// because we want to ignore false positives on numbers; for example, the string\n// \"1192\" is more likely to represent a number than a date even though it is\n// valid ISO 8601 representing 1192-01-01.\nexport function isTemporalString(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"string\" && isNaN(value) && isoParse(value);\n }\n}\n\n// Are these strings that might represent numbers? This is stricter than\n// coercion because we want to ignore false positives on e.g. empty strings.\nexport function isNumericString(values) {\n for (const value of values) {\n if (value == null) continue;\n if (typeof value !== \"string\") return false;\n if (!value.trim()) continue;\n return !isNaN(value);\n }\n}\n\nexport function isNumeric(values) {\n for (const value of values) {\n if (value == null) continue;\n return typeof value === \"number\";\n }\n}\n\n// Returns true if every non-null value in the specified iterable of values\n// passes the specified predicate, and there is at least one non-null value;\n// returns false if at least one non-null value does not pass the specified\n// predicate; otherwise returns undefined (as if all values are null).\nexport function isEvery(values, is) {\n let every;\n for (const value of values) {\n if (value == null) continue;\n if (!is(value)) return false;\n every = true;\n }\n return every;\n}\n\n// Mostly relies on d3-color, with a few extra color keywords. Currently this\n// strictly requires that the value be a string; we might want to apply string\n// coercion here, though note that d3-color instances would need to support\n// valueOf to work correctly with InternMap.\n// https://www.w3.org/TR/SVG11/painting.html#SpecifyingPaint\nexport function isColor(value) {\n if (typeof value !== \"string\") return false;\n value = value.toLowerCase().trim();\n return (\n value === \"none\" ||\n value === \"currentcolor\" ||\n (value.startsWith(\"url(\") && value.endsWith(\")\")) || // , e.g. pattern or gradient\n (value.startsWith(\"var(\") && value.endsWith(\")\")) || // CSS variable\n color(value) !== null\n );\n}\n\nexport function isOpacity(value) {\n return typeof value === \"number\" && ((0 <= value && value <= 1) || isNaN(value));\n}\n\nexport function isNoneish(value) {\n return value == null || isNone(value);\n}\n\nexport function isNone(value) {\n return /^\\s*none\\s*$/i.test(value);\n}\n\nexport function isRound(value) {\n return /^\\s*round\\s*$/i.test(value);\n}\n\nexport function maybeFrameAnchor(value = \"middle\") {\n return keyword(value, \"frameAnchor\", [\n \"middle\",\n \"top-left\",\n \"top\",\n \"top-right\",\n \"right\",\n \"bottom-right\",\n \"bottom\",\n \"bottom-left\",\n \"left\"\n ]);\n}\n\n// Like a sort comparator, returns a positive value if the given array of values\n// is in ascending order, a negative value if the values are in descending\n// order. Assumes monotonicity; only tests the first and last values.\nexport function orderof(values) {\n if (values == null) return;\n const first = values[0];\n const last = values[values.length - 1];\n return descending(first, last);\n}\n\n// Unlike {...defaults, ...options}, this ensures that any undefined (but\n// present) properties in options inherit the given default value.\nexport function inherit(options = {}, ...rest) {\n let o = options;\n for (const defaults of rest) {\n for (const key in defaults) {\n if (o[key] === undefined) {\n const value = defaults[key];\n if (o === options) o = {...o, [key]: value};\n else o[key] = value;\n }\n }\n }\n return o;\n}\n\n// Given an iterable of named things (objects with a name property), returns a\n// corresponding object with properties associated with the given name.\nexport function named(things) {\n console.warn(\"named iterables are deprecated; please use an object instead\");\n const names = new Set();\n return Object.fromEntries(\n Array.from(things, (thing) => {\n const {name} = thing;\n if (name == null) throw new Error(\"missing name\");\n const key = `${name}`;\n if (key === \"__proto__\") throw new Error(`illegal name: ${key}`);\n if (names.has(key)) throw new Error(`duplicate name: ${key}`);\n names.add(key);\n return [name, thing];\n })\n );\n}\n\nexport function maybeNamed(things) {\n return isIterable(things) ? named(things) : things;\n}\n","// Positional scales have associated axes, and for ordinal data, a point or band\n// scale is used instead of an ordinal scale.\nexport const position = Symbol(\"position\");\n\n// Color scales default to the turbo interpolator for quantitative data, and to\n// the Tableau10 scheme for ordinal data. Color scales may also have an\n// associated legend.\nexport const color = Symbol(\"color\");\n\n// Radius scales default to the sqrt type, have a default range of [0, 3], and a\n// default domain from 0 to the median first quartile of associated channels.\nexport const radius = Symbol(\"radius\");\n\n// Length scales default to the linear type, have a default range of [0, 12],\n// and a default domain from 0 to the median median of associated channels.\nexport const length = Symbol(\"length\");\n\n// Opacity scales have a default range of [0, 1], and a default domain from 0 to\n// the maximum value of associated channels.\nexport const opacity = Symbol(\"opacity\");\n\n// Symbol scales have a default range of categorical symbols.\nexport const symbol = Symbol(\"symbol\");\n\n// TODO Rather than hard-coding the list of known scale names, collect the names\n// and categories for each plot specification, so that custom marks can register\n// custom scales.\nexport const registry = new Map([\n [\"x\", position],\n [\"y\", position],\n [\"fx\", position],\n [\"fy\", position],\n [\"r\", radius],\n [\"color\", color],\n [\"opacity\", opacity],\n [\"symbol\", symbol],\n [\"length\", length]\n]);\n","import {symbolAsterisk, symbolDiamond2, symbolPlus, symbolSquare2, symbolTriangle2, symbolTimes} from \"d3\";\nimport {symbolCircle, symbolCross, symbolDiamond, symbolSquare, symbolStar, symbolTriangle, symbolWye} from \"d3\";\n\nexport const sqrt3 = Math.sqrt(3);\nexport const sqrt4_3 = 2 / sqrt3;\n\nconst symbolHexagon = {\n draw(context, size) {\n const rx = Math.sqrt(size / Math.PI),\n ry = rx * sqrt4_3,\n hy = ry / 2;\n context.moveTo(0, ry);\n context.lineTo(rx, hy);\n context.lineTo(rx, -hy);\n context.lineTo(0, -ry);\n context.lineTo(-rx, -hy);\n context.lineTo(-rx, hy);\n context.closePath();\n }\n};\n\nconst symbols = new Map([\n [\"asterisk\", symbolAsterisk],\n [\"circle\", symbolCircle],\n [\"cross\", symbolCross],\n [\"diamond\", symbolDiamond],\n [\"diamond2\", symbolDiamond2],\n [\"hexagon\", symbolHexagon],\n [\"plus\", symbolPlus],\n [\"square\", symbolSquare],\n [\"square2\", symbolSquare2],\n [\"star\", symbolStar],\n [\"times\", symbolTimes],\n [\"triangle\", symbolTriangle],\n [\"triangle2\", symbolTriangle2],\n [\"wye\", symbolWye]\n]);\n\nfunction isSymbolObject(value) {\n return value && typeof value.draw === \"function\";\n}\n\nexport function isSymbol(value) {\n if (isSymbolObject(value)) return true;\n if (typeof value !== \"string\") return false;\n return symbols.has(value.toLowerCase());\n}\n\nexport function maybeSymbol(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return symbol;\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return value;\n throw new Error(`invalid symbol: ${symbol}`);\n}\n\nexport function maybeSymbolChannel(symbol) {\n if (symbol == null || isSymbolObject(symbol)) return [undefined, symbol];\n if (typeof symbol === \"string\") {\n const value = symbols.get(`${symbol}`.toLowerCase());\n if (value) return [undefined, value];\n }\n return [symbol, undefined];\n}\n","let warnings = 0;\n\nexport function consumeWarnings() {\n const w = warnings;\n warnings = 0;\n return w;\n}\n\nexport function warn(message) {\n console.warn(message);\n ++warnings;\n}\n","import {\n interpolateBlues,\n interpolateBrBG,\n interpolateBuGn,\n interpolateBuPu,\n interpolateGnBu,\n interpolateGreens,\n interpolateGreys,\n interpolateOranges,\n interpolateOrRd,\n interpolatePiYG,\n interpolatePRGn,\n interpolatePuBu,\n interpolatePuBuGn,\n interpolatePuOr,\n interpolatePuRd,\n interpolatePurples,\n interpolateRdBu,\n interpolateRdGy,\n interpolateRdPu,\n interpolateRdYlBu,\n interpolateRdYlGn,\n interpolateReds,\n interpolateSpectral,\n interpolateYlGn,\n interpolateYlGnBu,\n interpolateYlOrBr,\n interpolateYlOrRd,\n interpolateTurbo,\n interpolateViridis,\n interpolateMagma,\n interpolateInferno,\n interpolatePlasma,\n interpolateCividis,\n interpolateCubehelixDefault,\n interpolateWarm,\n interpolateCool,\n interpolateRainbow,\n interpolateSinebow,\n quantize,\n schemeAccent,\n schemeBlues,\n schemeBrBG,\n schemeBuGn,\n schemeBuPu,\n schemeCategory10,\n schemeDark2,\n schemeGnBu,\n schemeGreens,\n schemeGreys,\n schemeOranges,\n schemeOrRd,\n schemePaired,\n schemePastel1,\n schemePastel2,\n schemePiYG,\n schemePRGn,\n schemePuBu,\n schemePuBuGn,\n schemePuOr,\n schemePuRd,\n schemePurples,\n schemeRdBu,\n schemeRdGy,\n schemeRdPu,\n schemeRdYlBu,\n schemeRdYlGn,\n schemeReds,\n schemeSet1,\n schemeSet2,\n schemeSet3,\n schemeSpectral,\n schemeTableau10,\n schemeYlGn,\n schemeYlGnBu,\n schemeYlOrBr,\n schemeYlOrRd\n} from \"d3\";\n\nconst ordinalSchemes = new Map([\n // categorical\n [\"accent\", schemeAccent],\n [\"category10\", schemeCategory10],\n [\"dark2\", schemeDark2],\n [\"paired\", schemePaired],\n [\"pastel1\", schemePastel1],\n [\"pastel2\", schemePastel2],\n [\"set1\", schemeSet1],\n [\"set2\", schemeSet2],\n [\"set3\", schemeSet3],\n [\"tableau10\", schemeTableau10],\n\n // diverging\n [\"brbg\", scheme11(schemeBrBG, interpolateBrBG)],\n [\"prgn\", scheme11(schemePRGn, interpolatePRGn)],\n [\"piyg\", scheme11(schemePiYG, interpolatePiYG)],\n [\"puor\", scheme11(schemePuOr, interpolatePuOr)],\n [\"rdbu\", scheme11(schemeRdBu, interpolateRdBu)],\n [\"rdgy\", scheme11(schemeRdGy, interpolateRdGy)],\n [\"rdylbu\", scheme11(schemeRdYlBu, interpolateRdYlBu)],\n [\"rdylgn\", scheme11(schemeRdYlGn, interpolateRdYlGn)],\n [\"spectral\", scheme11(schemeSpectral, interpolateSpectral)],\n\n // reversed diverging (for temperature data)\n [\"burd\", scheme11r(schemeRdBu, interpolateRdBu)],\n [\"buylrd\", scheme11r(schemeRdYlBu, interpolateRdYlBu)],\n\n // sequential (single-hue)\n [\"blues\", scheme9(schemeBlues, interpolateBlues)],\n [\"greens\", scheme9(schemeGreens, interpolateGreens)],\n [\"greys\", scheme9(schemeGreys, interpolateGreys)],\n [\"oranges\", scheme9(schemeOranges, interpolateOranges)],\n [\"purples\", scheme9(schemePurples, interpolatePurples)],\n [\"reds\", scheme9(schemeReds, interpolateReds)],\n\n // sequential (multi-hue)\n [\"turbo\", schemei(interpolateTurbo)],\n [\"viridis\", schemei(interpolateViridis)],\n [\"magma\", schemei(interpolateMagma)],\n [\"inferno\", schemei(interpolateInferno)],\n [\"plasma\", schemei(interpolatePlasma)],\n [\"cividis\", schemei(interpolateCividis)],\n [\"cubehelix\", schemei(interpolateCubehelixDefault)],\n [\"warm\", schemei(interpolateWarm)],\n [\"cool\", schemei(interpolateCool)],\n [\"bugn\", scheme9(schemeBuGn, interpolateBuGn)],\n [\"bupu\", scheme9(schemeBuPu, interpolateBuPu)],\n [\"gnbu\", scheme9(schemeGnBu, interpolateGnBu)],\n [\"orrd\", scheme9(schemeOrRd, interpolateOrRd)],\n [\"pubu\", scheme9(schemePuBu, interpolatePuBu)],\n [\"pubugn\", scheme9(schemePuBuGn, interpolatePuBuGn)],\n [\"purd\", scheme9(schemePuRd, interpolatePuRd)],\n [\"rdpu\", scheme9(schemeRdPu, interpolateRdPu)],\n [\"ylgn\", scheme9(schemeYlGn, interpolateYlGn)],\n [\"ylgnbu\", scheme9(schemeYlGnBu, interpolateYlGnBu)],\n [\"ylorbr\", scheme9(schemeYlOrBr, interpolateYlOrBr)],\n [\"ylorrd\", scheme9(schemeYlOrRd, interpolateYlOrRd)],\n\n // cyclical\n [\"rainbow\", schemeicyclical(interpolateRainbow)],\n [\"sinebow\", schemeicyclical(interpolateSinebow)]\n]);\n\nfunction scheme9(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 1) return [scheme[3][1]]; // favor midpoint\n if (n === 2) return [scheme[3][1], scheme[3][2]]; // favor darker\n n = Math.max(3, Math.floor(n));\n return n > 9 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][0], scheme[3][2]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize(interpolate, n) : scheme[n];\n };\n}\n\nfunction scheme11r(scheme, interpolate) {\n return ({length: n}) => {\n if (n === 2) return [scheme[3][2], scheme[3][0]]; // favor diverging extrema\n n = Math.max(3, Math.floor(n));\n return n > 11 ? quantize((t) => interpolate(1 - t), n) : scheme[n].slice().reverse();\n };\n}\n\nfunction schemei(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.max(2, Math.floor(n)));\n}\n\nfunction schemeicyclical(interpolate) {\n return ({length: n}) => quantize(interpolate, Math.floor(n) + 1).slice(0, -1);\n}\n\nexport function ordinalScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!ordinalSchemes.has(s)) throw new Error(`unknown ordinal scheme: ${s}`);\n return ordinalSchemes.get(s);\n}\n\nexport function ordinalRange(scheme, length) {\n const s = ordinalScheme(scheme);\n const r = typeof s === \"function\" ? s({length}) : s;\n return r.length !== length ? r.slice(0, length) : r;\n}\n\n// If the specified domain contains only booleans (ignoring null and undefined),\n// returns a corresponding range where false is mapped to the low color and true\n// is mapped to the high color of the specified scheme.\nexport function maybeBooleanRange(domain, scheme = \"greys\") {\n const range = new Set();\n const [f, t] = ordinalRange(scheme, 2);\n for (const value of domain) {\n if (value == null) continue;\n if (value === true) range.add(t);\n else if (value === false) range.add(f);\n else return;\n }\n return [...range];\n}\n\nconst quantitativeSchemes = new Map([\n // diverging\n [\"brbg\", interpolateBrBG],\n [\"prgn\", interpolatePRGn],\n [\"piyg\", interpolatePiYG],\n [\"puor\", interpolatePuOr],\n [\"rdbu\", interpolateRdBu],\n [\"rdgy\", interpolateRdGy],\n [\"rdylbu\", interpolateRdYlBu],\n [\"rdylgn\", interpolateRdYlGn],\n [\"spectral\", interpolateSpectral],\n\n // reversed diverging (for temperature data)\n [\"burd\", (t) => interpolateRdBu(1 - t)],\n [\"buylrd\", (t) => interpolateRdYlBu(1 - t)],\n\n // sequential (single-hue)\n [\"blues\", interpolateBlues],\n [\"greens\", interpolateGreens],\n [\"greys\", interpolateGreys],\n [\"purples\", interpolatePurples],\n [\"reds\", interpolateReds],\n [\"oranges\", interpolateOranges],\n\n // sequential (multi-hue)\n [\"turbo\", interpolateTurbo],\n [\"viridis\", interpolateViridis],\n [\"magma\", interpolateMagma],\n [\"inferno\", interpolateInferno],\n [\"plasma\", interpolatePlasma],\n [\"cividis\", interpolateCividis],\n [\"cubehelix\", interpolateCubehelixDefault],\n [\"warm\", interpolateWarm],\n [\"cool\", interpolateCool],\n [\"bugn\", interpolateBuGn],\n [\"bupu\", interpolateBuPu],\n [\"gnbu\", interpolateGnBu],\n [\"orrd\", interpolateOrRd],\n [\"pubugn\", interpolatePuBuGn],\n [\"pubu\", interpolatePuBu],\n [\"purd\", interpolatePuRd],\n [\"rdpu\", interpolateRdPu],\n [\"ylgnbu\", interpolateYlGnBu],\n [\"ylgn\", interpolateYlGn],\n [\"ylorbr\", interpolateYlOrBr],\n [\"ylorrd\", interpolateYlOrRd],\n\n // cyclical\n [\"rainbow\", interpolateRainbow],\n [\"sinebow\", interpolateSinebow]\n]);\n\nexport function quantitativeScheme(scheme) {\n const s = `${scheme}`.toLowerCase();\n if (!quantitativeSchemes.has(s)) throw new Error(`unknown quantitative scheme: ${s}`);\n return quantitativeSchemes.get(s);\n}\n\nconst divergingSchemes = new Set([\n \"brbg\",\n \"prgn\",\n \"piyg\",\n \"puor\",\n \"rdbu\",\n \"rdgy\",\n \"rdylbu\",\n \"rdylgn\",\n \"spectral\",\n \"burd\",\n \"buylrd\"\n]);\n\nexport function isDivergingScheme(scheme) {\n return scheme != null && divergingSchemes.has(`${scheme}`.toLowerCase());\n}\n","import {\n descending,\n extent,\n interpolateHcl,\n interpolateHsl,\n interpolateLab,\n interpolateNumber,\n interpolateRgb,\n interpolateRound,\n min,\n max,\n median,\n quantile,\n quantize,\n reverse as reverseof,\n scaleLinear,\n scaleLog,\n scalePow,\n scaleQuantile,\n scaleSymlog,\n scaleThreshold,\n scaleIdentity,\n ticks\n} from \"d3\";\nimport {positive, negative, finite} from \"../defined.js\";\nimport {arrayify, constant, orderof, slice, maybeNiceInterval, maybeRangeInterval} from \"../options.js\";\nimport {ordinalRange, quantitativeScheme} from \"./schemes.js\";\nimport {registry, radius, opacity, color, length} from \"./index.js\";\n\nexport const flip = (i) => (t) => i(1 - t);\nconst unit = [0, 1];\n\nconst interpolators = new Map([\n // numbers\n [\"number\", interpolateNumber],\n\n // color spaces\n [\"rgb\", interpolateRgb],\n [\"hsl\", interpolateHsl],\n [\"hcl\", interpolateHcl],\n [\"lab\", interpolateLab]\n]);\n\nexport function maybeInterpolator(interpolate) {\n const i = `${interpolate}`.toLowerCase();\n if (!interpolators.has(i)) throw new Error(`unknown interpolator: ${i}`);\n return interpolators.get(i);\n}\n\nexport function createScaleQ(\n key,\n scale,\n channels,\n {\n type,\n nice,\n clamp,\n zero,\n domain = inferAutoDomain(key, channels),\n unknown,\n round,\n scheme,\n interval,\n range = registry.get(key) === radius\n ? inferRadialRange(channels, domain)\n : registry.get(key) === length\n ? inferLengthRange(channels, domain)\n : registry.get(key) === opacity\n ? unit\n : undefined,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : type === \"cyclical\" ? \"rainbow\" : \"turbo\")\n : round\n ? interpolateRound\n : interpolateNumber,\n reverse\n }\n) {\n interval = maybeRangeInterval(interval, type);\n if (type === \"cyclical\" || type === \"sequential\") type = \"linear\"; // shorthand for color schemes\n reverse = !!reverse;\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n if (interpolate.length === 1) {\n if (reverse) {\n interpolate = flip(interpolate);\n reverse = false;\n }\n if (range === undefined) {\n range = Float64Array.from(domain, (_, i) => i / (domain.length - 1));\n if (range.length === 2) range = unit; // optimize common case of [0, 1]\n }\n scale.interpolate((range === unit ? constant : interpolatePiecewise)(interpolate));\n } else {\n scale.interpolate(interpolate);\n }\n\n // If a zero option is specified, we assume that the domain is numeric, and we\n // want to ensure that the domain crosses zero. However, note that the domain\n // may be reversed (descending) so we shouldn’t assume that the first value is\n // smaller than the last; and also it’s possible that the domain has more than\n // two values for a “poly” scale. And lastly be careful not to mutate input!\n if (zero) {\n const [min, max] = extent(domain);\n if (min > 0 || max < 0) {\n domain = slice(domain);\n if (orderof(domain) !== Math.sign(min)) domain[domain.length - 1] = 0;\n // [2, 1] or [-2, -1]\n else domain[0] = 0; // [1, 2] or [-1, -2]\n }\n }\n\n if (reverse) domain = reverseof(domain);\n scale.domain(domain).unknown(unknown);\n if (nice) scale.nice(maybeNice(nice, type)), (domain = scale.domain());\n if (range !== undefined) scale.range(range);\n if (clamp) scale.clamp(clamp);\n return {type, domain, range, scale, interpolate, interval};\n}\n\nfunction maybeNice(nice, type) {\n return nice === true ? undefined : typeof nice === \"number\" ? nice : maybeNiceInterval(nice, type);\n}\n\nexport function createScaleLinear(key, channels, options) {\n return createScaleQ(key, scaleLinear(), channels, options);\n}\n\nexport function createScaleSqrt(key, channels, options) {\n return createScalePow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScalePow(key, channels, {exponent = 1, ...options}) {\n return createScaleQ(key, scalePow().exponent(exponent), channels, {...options, type: \"pow\"});\n}\n\nexport function createScaleLog(key, channels, {base = 10, domain = inferLogDomain(channels), ...options}) {\n return createScaleQ(key, scaleLog().base(base), channels, {...options, domain});\n}\n\nexport function createScaleSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleQ(key, scaleSymlog().constant(constant), channels, options);\n}\n\nexport function createScaleQuantile(\n key,\n channels,\n {\n range,\n quantiles = range === undefined ? 5 : (range = [...range]).length, // deprecated; use n instead\n n = quantiles,\n scheme = \"rdylbu\",\n domain = inferQuantileDomain(channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n if (range === undefined) {\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n }\n if (domain.length > 0) {\n domain = scaleQuantile(domain, range === undefined ? {length: n} : range).quantiles();\n }\n return createScaleThreshold(key, channels, {domain, range, reverse, unknown});\n}\n\nexport function createScaleQuantize(\n key,\n channels,\n {\n range,\n n = range === undefined ? 5 : (range = [...range]).length,\n scheme = \"rdylbu\",\n domain = inferAutoDomain(key, channels),\n unknown,\n interpolate,\n reverse\n }\n) {\n const [min, max] = extent(domain);\n let thresholds;\n if (range === undefined) {\n thresholds = ticks(min, max, n); // approximate number of nice, round thresholds\n if (thresholds[0] <= min) thresholds.splice(0, 1); // drop exact lower bound\n if (thresholds[thresholds.length - 1] >= max) thresholds.pop(); // drop exact upper bound\n n = thresholds.length + 1;\n range =\n interpolate !== undefined\n ? quantize(interpolate, n)\n : registry.get(key) === color\n ? ordinalRange(scheme, n)\n : undefined;\n } else {\n thresholds = quantize(interpolateNumber(min, max), n + 1).slice(1, -1); // exactly n - 1 thresholds to match range\n if (min instanceof Date) thresholds = thresholds.map((x) => new Date(x)); // preserve date types\n }\n if (orderof(arrayify(domain)) < 0) thresholds.reverse(); // preserve descending domain\n return createScaleThreshold(key, channels, {domain: thresholds, range, reverse, unknown});\n}\n\nexport function createScaleThreshold(\n key,\n channels,\n {\n domain = [0], // explicit thresholds in ascending order\n unknown,\n scheme = \"rdylbu\",\n interpolate,\n range = interpolate !== undefined\n ? quantize(interpolate, domain.length + 1)\n : registry.get(key) === color\n ? ordinalRange(scheme, domain.length + 1)\n : undefined,\n reverse\n }\n) {\n domain = arrayify(domain);\n const sign = orderof(domain); // preserve descending domain\n if (!isNaN(sign) && !isOrdered(domain, sign)) throw new Error(`the ${key} scale has a non-monotonic domain`);\n if (reverse) range = reverseof(range); // domain ascending, so reverse range\n return {\n type: \"threshold\",\n scale: scaleThreshold(sign < 0 ? reverseof(domain) : domain, range === undefined ? [] : range).unknown(unknown),\n domain,\n range\n };\n}\n\nfunction isOrdered(domain, sign) {\n for (let i = 1, n = domain.length, d = domain[0]; i < n; ++i) {\n const s = descending(d, (d = domain[i]));\n if (s !== 0 && s !== sign) return false;\n }\n return true;\n}\n\nexport function createScaleIdentity() {\n return {type: \"identity\", scale: scaleIdentity()};\n}\n\nexport function inferDomain(channels, f = finite) {\n return channels.length\n ? [\n min(channels, ({value}) => (value === undefined ? value : min(value, f))),\n max(channels, ({value}) => (value === undefined ? value : max(value, f)))\n ]\n : [0, 1];\n}\n\nfunction inferAutoDomain(key, channels) {\n const type = registry.get(key);\n return (type === radius || type === opacity || type === length ? inferZeroDomain : inferDomain)(channels);\n}\n\nfunction inferZeroDomain(channels) {\n return [0, channels.length ? max(channels, ({value}) => (value === undefined ? value : max(value, finite))) : 1];\n}\n\n// We don’t want the upper bound of the radial domain to be zero, as this would\n// be degenerate, so we ignore nonpositive values. We also don’t want the\n// maximum default radius to exceed 30px.\nfunction inferRadialRange(channels, domain) {\n const hint = channels.find(({radius}) => radius !== undefined);\n if (hint !== undefined) return [0, hint.radius]; // a natural maximum radius, e.g. hexbins\n const h25 = quantile(channels, 0.5, ({value}) => (value === undefined ? NaN : quantile(value, 0.25, positive)));\n const range = domain.map((d) => 3 * Math.sqrt(d / h25));\n const k = 30 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\n// We want a length scale’s domain to go from zero to a positive value, and to\n// treat negative lengths if any as inverted vectors of equivalent magnitude. We\n// also don’t want the maximum default length to exceed 60px.\nfunction inferLengthRange(channels, domain) {\n const h50 = median(channels, ({value}) => (value === undefined ? NaN : median(value, Math.abs)));\n const range = domain.map((d) => (12 * d) / h50);\n const k = 60 / max(range);\n return k < 1 ? range.map((r) => r * k) : range;\n}\n\nfunction inferLogDomain(channels) {\n for (const {value} of channels) {\n if (value !== undefined) {\n for (let v of value) {\n if (v > 0) return inferDomain(channels, positive);\n if (v < 0) return inferDomain(channels, negative);\n }\n }\n }\n return [1, 10];\n}\n\nfunction inferQuantileDomain(channels) {\n const domain = [];\n for (const {value} of channels) {\n if (value === undefined) continue;\n for (const v of value) domain.push(v);\n }\n return domain;\n}\n\nexport function interpolatePiecewise(interpolate) {\n return (i, j) => (t) => interpolate(i + t * (j - i));\n}\n","import {\n descending,\n interpolateNumber,\n interpolateRgb,\n piecewise,\n scaleDiverging,\n scaleDivergingLog,\n scaleDivergingPow,\n scaleDivergingSymlog\n} from \"d3\";\nimport {positive, negative} from \"../defined.js\";\nimport {quantitativeScheme} from \"./schemes.js\";\nimport {registry, color} from \"./index.js\";\nimport {inferDomain, maybeInterpolator, flip, interpolatePiecewise} from \"./quantitative.js\";\n\nfunction createScaleD(\n key,\n scale,\n transform,\n channels,\n {\n type,\n nice,\n clamp,\n domain = inferDomain(channels),\n unknown,\n pivot = 0,\n scheme,\n range,\n symmetric = true,\n interpolate = registry.get(key) === color\n ? scheme == null && range !== undefined\n ? interpolateRgb\n : quantitativeScheme(scheme !== undefined ? scheme : \"rdbu\")\n : interpolateNumber,\n reverse\n }\n) {\n pivot = +pivot;\n let [min, max] = domain;\n if (descending(min, max) < 0) ([min, max] = [max, min]), (reverse = !reverse);\n min = Math.min(min, pivot);\n max = Math.max(max, pivot);\n\n // Sometimes interpolate is a named interpolator, such as \"lab\" for Lab color\n // space. Other times interpolate is a function that takes two arguments and\n // is used in conjunction with the range. And other times the interpolate\n // function is a “fixed” interpolator on the [0, 1] interval, as when a\n // color scheme such as interpolateRdBu is used.\n if (typeof interpolate !== \"function\") {\n interpolate = maybeInterpolator(interpolate);\n }\n\n // If an explicit range is specified, promote it to a piecewise interpolator.\n if (range !== undefined) {\n interpolate =\n interpolate.length === 1 ? interpolatePiecewise(interpolate)(...range) : piecewise(interpolate, range);\n }\n\n // Reverse before normalization.\n if (reverse) interpolate = flip(interpolate);\n\n // Normalize the interpolator for symmetric difference around the pivot.\n if (symmetric) {\n const mid = transform.apply(pivot);\n const mindelta = mid - transform.apply(min);\n const maxdelta = transform.apply(max) - mid;\n if (mindelta < maxdelta) min = transform.invert(mid - maxdelta);\n else if (mindelta > maxdelta) max = transform.invert(mid + mindelta);\n }\n\n scale.domain([min, pivot, max]).unknown(unknown).interpolator(interpolate);\n if (clamp) scale.clamp(clamp);\n if (nice) scale.nice(nice);\n return {type, domain: [min, max], pivot, interpolate, scale};\n}\n\nexport function createScaleDiverging(key, channels, options) {\n return createScaleD(key, scaleDiverging(), transformIdentity, channels, options);\n}\n\nexport function createScaleDivergingSqrt(key, channels, options) {\n return createScaleDivergingPow(key, channels, {...options, exponent: 0.5});\n}\n\nexport function createScaleDivergingPow(key, channels, {exponent = 1, ...options}) {\n return createScaleD(key, scaleDivergingPow().exponent((exponent = +exponent)), transformPow(exponent), channels, {\n ...options,\n type: \"diverging-pow\"\n });\n}\n\nexport function createScaleDivergingLog(\n key,\n channels,\n {base = 10, pivot = 1, domain = inferDomain(channels, pivot < 0 ? negative : positive), ...options}\n) {\n return createScaleD(key, scaleDivergingLog().base((base = +base)), transformLog, channels, {\n domain,\n pivot,\n ...options\n });\n}\n\nexport function createScaleDivergingSymlog(key, channels, {constant = 1, ...options}) {\n return createScaleD(\n key,\n scaleDivergingSymlog().constant((constant = +constant)),\n transformSymlog(constant),\n channels,\n options\n );\n}\n\nconst transformIdentity = {\n apply(x) {\n return x;\n },\n invert(x) {\n return x;\n }\n};\n\nconst transformLog = {\n apply: Math.log,\n invert: Math.exp\n};\n\nconst transformSqrt = {\n apply(x) {\n return Math.sign(x) * Math.sqrt(Math.abs(x));\n },\n invert(x) {\n return Math.sign(x) * (x * x);\n }\n};\n\nfunction transformPow(exponent) {\n return exponent === 0.5\n ? transformSqrt\n : {\n apply(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), exponent);\n },\n invert(x) {\n return Math.sign(x) * Math.pow(Math.abs(x), 1 / exponent);\n }\n };\n}\n\nfunction transformSymlog(constant) {\n return {\n apply(x) {\n return Math.sign(x) * Math.log1p(Math.abs(x / constant));\n },\n invert(x) {\n return Math.sign(x) * Math.expm1(Math.abs(x)) * constant;\n }\n };\n}\n","import {scaleTime, scaleUtc} from \"d3\";\nimport {createScaleQ} from \"./quantitative.js\";\n\nfunction createScaleT(key, scale, channels, options) {\n return createScaleQ(key, scale, channels, options);\n}\n\nexport function createScaleTime(key, channels, options) {\n return createScaleT(key, scaleTime(), channels, options);\n}\n\nexport function createScaleUtc(key, channels, options) {\n return createScaleT(key, scaleUtc(), channels, options);\n}\n","import {InternSet, extent, quantize, reverse as reverseof, sort, symbolsFill, symbolsStroke} from \"d3\";\nimport {scaleBand, scaleOrdinal, scalePoint, scaleImplicit} from \"d3\";\nimport {ascendingDefined} from \"../defined.js\";\nimport {isNoneish, map, maybeRangeInterval} from \"../options.js\";\nimport {maybeSymbol} from \"../symbol.js\";\nimport {registry, color, position, symbol} from \"./index.js\";\nimport {maybeBooleanRange, ordinalScheme, quantitativeScheme} from \"./schemes.js\";\n\n// This denotes an implicitly ordinal color scale: the scale type was not set,\n// but the associated values are strings or booleans. If the associated defined\n// values are entirely boolean, the range will default to greys. You can opt out\n// of this by setting the type explicitly.\nexport const ordinalImplicit = Symbol(\"ordinal\");\n\nfunction createScaleO(key, scale, channels, {type, interval, domain, range, reverse, hint}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n if (type === \"categorical\" || type === ordinalImplicit) type = \"ordinal\"; // shorthand for color schemes\n if (reverse) domain = reverseof(domain);\n scale.domain(domain);\n if (range !== undefined) {\n // If the range is specified as a function, pass it the domain.\n if (typeof range === \"function\") range = range(domain);\n scale.range(range);\n }\n return {type, domain, range, scale, hint, interval};\n}\n\nexport function createScaleOrdinal(key, channels, {type, interval, domain, range, scheme, unknown, ...options}) {\n interval = maybeRangeInterval(interval, type);\n if (domain === undefined) domain = inferDomain(channels, interval, key);\n let hint;\n if (registry.get(key) === symbol) {\n hint = inferSymbolHint(channels);\n range = range === undefined ? inferSymbolRange(hint) : map(range, maybeSymbol);\n } else if (registry.get(key) === color) {\n if (range === undefined && (type === \"ordinal\" || type === ordinalImplicit)) {\n range = maybeBooleanRange(domain, scheme);\n if (range !== undefined) scheme = undefined; // Don’t re-apply scheme.\n }\n if (scheme === undefined && range === undefined) {\n scheme = type === \"ordinal\" ? \"turbo\" : \"tableau10\";\n }\n if (scheme !== undefined) {\n if (range !== undefined) {\n const interpolate = quantitativeScheme(scheme);\n const t0 = range[0],\n d = range[1] - range[0];\n range = ({length: n}) => quantize((t) => interpolate(t0 + d * t), n);\n } else {\n range = ordinalScheme(scheme);\n }\n }\n }\n if (unknown === scaleImplicit) {\n throw new Error(`implicit unknown on ${key} scale is not supported`);\n }\n return createScaleO(key, scaleOrdinal().unknown(unknown), channels, {...options, type, domain, range, hint});\n}\n\nexport function createScalePoint(key, channels, {align = 0.5, padding = 0.5, ...options}) {\n return maybeRound(scalePoint().align(align).padding(padding), channels, options, key);\n}\n\nexport function createScaleBand(\n key,\n channels,\n {\n align = 0.5,\n padding = 0.1,\n paddingInner = padding,\n paddingOuter = key === \"fx\" || key === \"fy\" ? 0 : padding,\n ...options\n }\n) {\n return maybeRound(\n scaleBand().align(align).paddingInner(paddingInner).paddingOuter(paddingOuter),\n channels,\n options,\n key\n );\n}\n\nfunction maybeRound(scale, channels, options, key) {\n let {round} = options;\n if (round !== undefined) scale.round((round = !!round));\n scale = createScaleO(key, scale, channels, options);\n scale.round = round; // preserve for autoScaleRound\n return scale;\n}\n\nfunction inferDomain(channels, interval, key) {\n const values = new InternSet();\n for (const {value, domain} of channels) {\n if (domain !== undefined) return domain(); // see channelDomain\n if (value === undefined) continue;\n for (const v of value) values.add(v);\n }\n if (interval !== undefined) {\n const [min, max] = extent(values).map(interval.floor, interval);\n return interval.range(min, interval.offset(max));\n }\n if (values.size > 10e3 && registry.get(key) === position) {\n throw new Error(`implicit ordinal domain of ${key} scale has more than 10,000 values`);\n }\n return sort(values, ascendingDefined);\n}\n\n// If all channels provide a consistent hint, propagate it to the scale.\nfunction inferHint(channels, key) {\n let value;\n for (const {hint} of channels) {\n const candidate = hint?.[key];\n if (candidate === undefined) continue; // no hint here\n if (value === undefined) value = candidate;\n // first hint\n else if (value !== candidate) return; // inconsistent hint\n }\n return value;\n}\n\nfunction inferSymbolHint(channels) {\n return {\n fill: inferHint(channels, \"fill\"),\n stroke: inferHint(channels, \"stroke\")\n };\n}\n\nfunction inferSymbolRange(hint) {\n return isNoneish(hint.fill) ? symbolsStroke : symbolsFill;\n}\n","import {\n isOrdinal,\n isTemporal,\n isTemporalString,\n isNumericString,\n isScaleOptions,\n map,\n slice,\n coerceNumbers,\n coerceDates\n} from \"./options.js\";\nimport {registry, color, position, radius, opacity, symbol, length} from \"./scales/index.js\";\nimport {\n createScaleLinear,\n createScaleSqrt,\n createScalePow,\n createScaleLog,\n createScaleSymlog,\n createScaleQuantile,\n createScaleQuantize,\n createScaleThreshold,\n createScaleIdentity\n} from \"./scales/quantitative.js\";\nimport {\n createScaleDiverging,\n createScaleDivergingSqrt,\n createScaleDivergingPow,\n createScaleDivergingLog,\n createScaleDivergingSymlog\n} from \"./scales/diverging.js\";\nimport {isDivergingScheme} from \"./scales/schemes.js\";\nimport {createScaleTime, createScaleUtc} from \"./scales/temporal.js\";\nimport {createScaleOrdinal, createScalePoint, createScaleBand, ordinalImplicit} from \"./scales/ordinal.js\";\nimport {maybeSymbol} from \"./symbol.js\";\nimport {warn} from \"./warnings.js\";\n\nexport function createScales(\n channelsByScale,\n {\n label: globalLabel,\n inset: globalInset = 0,\n insetTop: globalInsetTop = globalInset,\n insetRight: globalInsetRight = globalInset,\n insetBottom: globalInsetBottom = globalInset,\n insetLeft: globalInsetLeft = globalInset,\n round,\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n facet: {label: facetLabel = globalLabel} = {},\n ...options\n } = {}\n) {\n const scales = {};\n for (const [key, channels] of channelsByScale) {\n const scaleOptions = options[key];\n const scale = createScale(key, channels, {\n round: registry.get(key) === position ? round : undefined, // only for position\n nice,\n clamp,\n zero,\n align,\n padding,\n projection,\n ...scaleOptions\n });\n if (scale) {\n // populate generic scale options (percent, transform, insets)\n let {\n label = key === \"fx\" || key === \"fy\" ? facetLabel : globalLabel,\n percent,\n transform,\n inset,\n insetTop = inset !== undefined ? inset : key === \"y\" ? globalInsetTop : 0, // not fy\n insetRight = inset !== undefined ? inset : key === \"x\" ? globalInsetRight : 0, // not fx\n insetBottom = inset !== undefined ? inset : key === \"y\" ? globalInsetBottom : 0, // not fy\n insetLeft = inset !== undefined ? inset : key === \"x\" ? globalInsetLeft : 0 // not fx\n } = scaleOptions || {};\n if (transform == null) transform = undefined;\n else if (typeof transform !== \"function\") throw new Error(\"invalid scale transform; not a function\");\n scale.percent = !!percent;\n scale.label = label === undefined ? inferScaleLabel(channels, scale) : label;\n scale.transform = transform;\n if (key === \"x\" || key === \"fx\") {\n scale.insetLeft = +insetLeft;\n scale.insetRight = +insetRight;\n } else if (key === \"y\" || key === \"fy\") {\n scale.insetTop = +insetTop;\n scale.insetBottom = +insetBottom;\n }\n scales[key] = scale;\n }\n }\n return scales;\n}\n\nexport function createScaleFunctions(scales) {\n return Object.fromEntries(\n Object.entries(scales)\n .filter(([, {scale}]) => scale) // drop identity scales\n .map(([name, {scale, type, interval, label}]) => {\n scale.type = type; // for axis\n if (interval != null) scale.interval = interval; // for axis\n if (label != null) scale.label = label; // for axis\n return [name, scale];\n })\n );\n}\n\n// Mutates scale.range!\nexport function autoScaleRange(scales, dimensions) {\n const {x, y, fx, fy} = scales;\n const superdimensions = fx || fy ? outerDimensions(dimensions) : dimensions;\n if (fx) autoScaleRangeX(fx, superdimensions);\n if (fy) autoScaleRangeY(fy, superdimensions);\n const subdimensions = fx || fy ? innerDimensions(scales, dimensions) : dimensions;\n if (x) autoScaleRangeX(x, subdimensions);\n if (y) autoScaleRangeY(y, subdimensions);\n}\n\n// Channels can have labels; if all the channels for a given scale are\n// consistently labeled (i.e., have the same value if not undefined), and the\n// corresponding scale doesn’t already have an explicit label, then the\n// channels’ label is promoted to the scale. This inferred label should have an\n// orientation-appropriate arrow added when used as an axis, but we don’t want\n// to add the arrow when the label is set explicitly as an option; so, the\n// inferred label is distinguished as an object with an “inferred” property.\nfunction inferScaleLabel(channels = [], scale) {\n let label;\n for (const {label: l} of channels) {\n if (l === undefined) continue;\n if (label === undefined) label = l;\n else if (label !== l) return;\n }\n if (label === undefined) return;\n // Ignore the implicit label for temporal scales if it’s simply “date”.\n if (isTemporalScale(scale) && /^(date|time|year)$/i.test(label)) return;\n if (!isOrdinalScale(scale) && scale.percent) label = `${label} (%)`;\n return {inferred: true, toString: () => label};\n}\n\n// Returns the dimensions of the outer frame; this is subdivided into facets\n// with the margins of each facet collapsing into the outer margins.\nexport function outerDimensions(dimensions) {\n const {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width,\n height,\n facet: {\n marginTop: facetMarginTop,\n marginRight: facetMarginRight,\n marginBottom: facetMarginBottom,\n marginLeft: facetMarginLeft\n }\n } = dimensions;\n return {\n marginTop: Math.max(marginTop, facetMarginTop),\n marginRight: Math.max(marginRight, facetMarginRight),\n marginBottom: Math.max(marginBottom, facetMarginBottom),\n marginLeft: Math.max(marginLeft, facetMarginLeft),\n width,\n height\n };\n}\n\n// Returns the dimensions of each facet.\nexport function innerDimensions({fx, fy}, dimensions) {\n const {marginTop, marginRight, marginBottom, marginLeft, width, height} = outerDimensions(dimensions);\n return {\n marginTop,\n marginRight,\n marginBottom,\n marginLeft,\n width: fx ? fx.scale.bandwidth() + marginLeft + marginRight : width,\n height: fy ? fy.scale.bandwidth() + marginTop + marginBottom : height\n };\n}\n\nfunction autoScaleRangeX(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetLeft, insetRight} = scale;\n const {width, marginLeft = 0, marginRight = 0} = dimensions;\n const left = marginLeft + insetLeft;\n const right = width - marginRight - insetRight;\n scale.range = [left, Math.max(left, right)];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRangeY(scale, dimensions) {\n if (scale.range === undefined) {\n const {insetTop, insetBottom} = scale;\n const {height, marginTop = 0, marginBottom = 0} = dimensions;\n const top = marginTop + insetTop;\n const bottom = height - marginBottom - insetBottom;\n scale.range = [Math.max(top, bottom), top];\n if (!isOrdinalScale(scale)) scale.range = piecewiseRange(scale);\n else scale.range.reverse();\n scale.scale.range(scale.range);\n }\n autoScaleRound(scale);\n}\n\nfunction autoScaleRound(scale) {\n if (scale.round === undefined && isBandScale(scale) && roundError(scale) <= 30) {\n scale.scale.round(true);\n }\n}\n\n// If we were to turn on rounding for this band or point scale, how much wasted\n// space would it introduce (on both ends of the range)? This must match\n// d3.scaleBand’s rounding behavior:\n// https://github.com/d3/d3-scale/blob/83555bd759c7314420bd4240642beda5e258db9e/src/band.js#L20-L32\nfunction roundError({scale}) {\n const n = scale.domain().length;\n const [start, stop] = scale.range();\n const paddingInner = scale.paddingInner ? scale.paddingInner() : 1;\n const paddingOuter = scale.paddingOuter ? scale.paddingOuter() : scale.padding();\n const m = n - paddingInner;\n const step = Math.abs(stop - start) / Math.max(1, m + paddingOuter * 2);\n return (step - Math.floor(step)) * m;\n}\n\nfunction piecewiseRange(scale) {\n const length = scale.scale.domain().length + isThresholdScale(scale);\n if (!(length > 2)) return scale.range;\n const [start, end] = scale.range;\n return Array.from({length}, (_, i) => start + (i / (length - 1)) * (end - start));\n}\n\nexport function normalizeScale(key, scale, hint) {\n return createScale(key, hint === undefined ? undefined : [{hint}], {...scale});\n}\n\nfunction createScale(key, channels = [], options = {}) {\n const type = inferScaleType(key, channels, options);\n\n // Warn for common misuses of implicit ordinal scales. We disable this test if\n // you specify a scale interval or if you set the domain or range explicitly,\n // since setting the domain or range (typically with a cardinality of more than\n // two) is another indication that you intended for the scale to be ordinal; we\n // also disable it for facet scales since these are always band scales.\n if (\n options.type === undefined &&\n options.domain === undefined &&\n options.range === undefined &&\n options.interval == null &&\n key !== \"fx\" &&\n key !== \"fy\" &&\n isOrdinalScale({type})\n ) {\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isTemporal))\n warn(\n `Warning: some data associated with the ${key} scale are dates. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., d3.utcDay), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isTemporalString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be dates (e.g., YYYY-MM-DD). If these strings represent dates, you should parse them to Date objects. Dates are typically associated with a \"utc\" or \"time\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you are using a bar mark, you probably want a rect mark with the interval option instead; if you are using a group transform, you probably want a bin transform instead. If you want to treat this data as ordinal, you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n else if (values.some(isNumericString))\n warn(\n `Warning: some data associated with the ${key} scale are strings that appear to be numbers. If these strings represent numbers, you should parse or coerce them to numbers. Numbers are typically associated with a \"linear\" scale rather than a \"${formatScaleType(\n type\n )}\" scale. If you want to treat this data as ordinal, you can specify the interval of the ${key} scale (e.g., 1 for integers), or you can suppress this warning by setting the type of the ${key} scale to \"${formatScaleType(\n type\n )}\".`\n );\n }\n\n options.type = type; // Mutates input!\n\n // Once the scale type is known, coerce the associated channel values and any\n // explicitly-specified domain to the expected type.\n switch (type) {\n case \"diverging\":\n case \"diverging-sqrt\":\n case \"diverging-pow\":\n case \"diverging-log\":\n case \"diverging-symlog\":\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n case \"sqrt\":\n case \"threshold\":\n case \"quantile\":\n case \"pow\":\n case \"log\":\n case \"symlog\":\n options = coerceType(channels, options, coerceNumbers);\n break;\n case \"identity\":\n switch (registry.get(key)) {\n case position:\n options = coerceType(channels, options, coerceNumbers);\n break;\n case symbol:\n options = coerceType(channels, options, coerceSymbols);\n break;\n }\n break;\n case \"utc\":\n case \"time\":\n options = coerceType(channels, options, coerceDates);\n break;\n }\n\n switch (type) {\n case \"diverging\":\n return createScaleDiverging(key, channels, options);\n case \"diverging-sqrt\":\n return createScaleDivergingSqrt(key, channels, options);\n case \"diverging-pow\":\n return createScaleDivergingPow(key, channels, options);\n case \"diverging-log\":\n return createScaleDivergingLog(key, channels, options);\n case \"diverging-symlog\":\n return createScaleDivergingSymlog(key, channels, options);\n case \"categorical\":\n case \"ordinal\":\n case ordinalImplicit:\n return createScaleOrdinal(key, channels, options);\n case \"cyclical\":\n case \"sequential\":\n case \"linear\":\n return createScaleLinear(key, channels, options);\n case \"sqrt\":\n return createScaleSqrt(key, channels, options);\n case \"threshold\":\n return createScaleThreshold(key, channels, options);\n case \"quantile\":\n return createScaleQuantile(key, channels, options);\n case \"quantize\":\n return createScaleQuantize(key, channels, options);\n case \"pow\":\n return createScalePow(key, channels, options);\n case \"log\":\n return createScaleLog(key, channels, options);\n case \"symlog\":\n return createScaleSymlog(key, channels, options);\n case \"utc\":\n return createScaleUtc(key, channels, options);\n case \"time\":\n return createScaleTime(key, channels, options);\n case \"point\":\n return createScalePoint(key, channels, options);\n case \"band\":\n return createScaleBand(key, channels, options);\n case \"identity\":\n return registry.get(key) === position ? createScaleIdentity() : {type: \"identity\"};\n case undefined:\n return;\n default:\n throw new Error(`unknown scale type: ${type}`);\n }\n}\n\nfunction formatScaleType(type) {\n return typeof type === \"symbol\" ? type.description : type;\n}\n\n// A special type symbol when the x and y scales are replaced with a projection.\nconst typeProjection = {toString: () => \"projection\"};\n\nfunction inferScaleType(key, channels, {type, domain, range, scheme, pivot, projection}) {\n // The facet scales are always band scales; this cannot be changed.\n if (key === \"fx\" || key === \"fy\") return \"band\";\n\n // If a projection is specified, the x- and y-scales are disabled; these\n // channels will be projected rather than scaled. (But still check that none\n // of the associated channels are incompatible with a projection.)\n if ((key === \"x\" || key === \"y\") && projection != null) type = typeProjection;\n\n // If a channel dictates a scale type, make sure that it is consistent with\n // the user-specified scale type (if any) and all other channels. For example,\n // barY requires x to be a band scale and disallows any other scale type.\n for (const {type: t} of channels) {\n if (t === undefined) continue;\n else if (type === undefined) type = t;\n else if (type !== t) throw new Error(`scale incompatible with channel: ${type} !== ${t}`);\n }\n\n // If the scale, a channel, or user specified a (consistent) type, return it.\n if (type === typeProjection) return;\n if (type !== undefined) return type;\n\n // If there’s no data (and no type) associated with this scale, don’t create a scale.\n if (domain === undefined && !channels.some(({value}) => value !== undefined)) return;\n\n // Some scales have default types.\n const kind = registry.get(key);\n if (kind === radius) return \"sqrt\";\n if (kind === opacity || kind === length) return \"linear\";\n if (kind === symbol) return \"ordinal\";\n\n // If the domain or range has more than two values, assume it’s ordinal. You\n // can still use a “piecewise” (or “polylinear”) scale, but you must set the\n // type explicitly.\n if ((domain || range || []).length > 2) return asOrdinalType(kind);\n\n // Otherwise, infer the scale type from the data! Prefer the domain, if\n // present, over channels. (The domain and channels should be consistently\n // typed, and the domain is more explicit and typically much smaller.) We only\n // check the first defined value for expedience and simplicity; we expect\n // that the types are consistent.\n if (domain !== undefined) {\n if (isOrdinal(domain)) return asOrdinalType(kind);\n if (isTemporal(domain)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n }\n\n // If any channel is ordinal or temporal, it takes priority.\n const values = channels.map(({value}) => value).filter((value) => value !== undefined);\n if (values.some(isOrdinal)) return asOrdinalType(kind);\n if (values.some(isTemporal)) return \"utc\";\n if (kind === color && (pivot != null || isDivergingScheme(scheme))) return \"diverging\";\n return \"linear\";\n}\n\n// Positional scales default to a point scale instead of an ordinal scale.\nfunction asOrdinalType(kind) {\n switch (kind) {\n case position:\n return \"point\";\n case color:\n return ordinalImplicit;\n default:\n return \"ordinal\";\n }\n}\n\nexport function isTemporalScale({type}) {\n return type === \"time\" || type === \"utc\";\n}\n\nexport function isOrdinalScale({type}) {\n return type === \"ordinal\" || type === \"point\" || type === \"band\" || type === ordinalImplicit;\n}\n\nexport function isThresholdScale({type}) {\n return type === \"threshold\";\n}\n\nfunction isBandScale({type}) {\n return type === \"point\" || type === \"band\";\n}\n\nexport function isDivergingScale({type}) {\n return /^diverging($|-)/.test(type);\n}\n\n// Certain marks have special behavior if a scale is collapsed, i.e. if the\n// domain is degenerate and represents only a single value such as [3, 3]; for\n// example, a rect will span the full extent of the chart along a collapsed\n// dimension (whereas a dot will simply be drawn in the center).\nexport function isCollapsed(scale) {\n if (scale === undefined) return true; // treat missing scale as collapsed\n const domain = scale.domain();\n const value = scale(domain[0]);\n for (let i = 1, n = domain.length; i < n; ++i) {\n if (scale(domain[i]) - value) {\n return false;\n }\n }\n return true;\n}\n\n// Mutates channel.value!\nfunction coerceType(channels, {domain, ...options}, coerceValues) {\n for (const c of channels) {\n if (c.value !== undefined) {\n c.value = coerceValues(c.value);\n }\n }\n return {\n domain: domain === undefined ? domain : coerceValues(domain),\n ...options\n };\n}\n\nfunction coerceSymbols(values) {\n return map(values, maybeSymbol);\n}\n\nexport function scale(options = {}) {\n let scale;\n for (const key in options) {\n if (!registry.has(key)) continue; // ignore unknown properties\n if (!isScaleOptions(options[key])) continue; // e.g., ignore {color: \"red\"}\n if (scale !== undefined) throw new Error(\"ambiguous scale definition; multiple scales found\");\n scale = exposeScale(normalizeScale(key, options[key]));\n }\n if (scale === undefined) throw new Error(\"invalid scale definition; no scale found\");\n return scale;\n}\n\nexport function exposeScales(scaleDescriptors) {\n return (key) => {\n if (!registry.has((key = `${key}`))) throw new Error(`unknown scale: ${key}`);\n return key in scaleDescriptors ? exposeScale(scaleDescriptors[key]) : undefined;\n };\n}\n\n// Note: axis- and legend-related properties (such as label, ticks and\n// tickFormat) are not included here as they do not affect the scale’s behavior.\nfunction exposeScale({scale, type, domain, range, interpolate, interval, transform, percent, pivot}) {\n if (type === \"identity\") return {type: \"identity\", apply: (d) => d, invert: (d) => d};\n const unknown = scale.unknown ? scale.unknown() : undefined;\n return {\n type,\n domain: slice(domain), // defensive copy\n ...(range !== undefined && {range: slice(range)}), // defensive copy\n ...(transform !== undefined && {transform}),\n ...(percent && {percent}), // only exposed if truthy\n ...(unknown !== undefined && {unknown}),\n ...(interval !== undefined && {interval}),\n\n // quantitative\n ...(interpolate !== undefined && {interpolate}),\n ...(scale.clamp && {clamp: scale.clamp()}),\n\n // diverging (always asymmetric; we never want to apply the symmetric transform twice)\n ...(pivot !== undefined && {pivot, symmetric: false}),\n\n // log, diverging-log\n ...(scale.base && {base: scale.base()}),\n\n // pow, diverging-pow\n ...(scale.exponent && {exponent: scale.exponent()}),\n\n // symlog, diverging-symlog\n ...(scale.constant && {constant: scale.constant()}),\n\n // band, point\n ...(scale.align && {align: scale.align(), round: scale.round()}),\n ...(scale.padding &&\n (scale.paddingInner\n ? {paddingInner: scale.paddingInner(), paddingOuter: scale.paddingOuter()}\n : {padding: scale.padding()})),\n ...(scale.bandwidth && {bandwidth: scale.bandwidth(), step: scale.step()}),\n\n // utilities\n apply: (t) => scale(t),\n ...(scale.invert && {invert: (t) => scale.invert(t)})\n };\n}\n","export enum ScrollDirection {\n SCROLL_NONE,\n SCROLL_BACKWARD,\n SCROLL_FORWARD,\n}\n\nexport enum Position {\n TOP,\n RIGHT,\n BOTTOM,\n LEFT,\n}\n\nexport const OPTIONS_DEFAULT_DOMAIN_TYPE = 'hour';\n\nexport const OPTIONS_DEFAULT_SUBDOMAIN_TYPE = 'minute';\nexport const OPTIONS_DEFAULT_SUBDOMAIN_WIDTH = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT = 10;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_GUTTER = 2;\nexport const OPTIONS_DEFAULT_SUBDOMAIN_RADIUS = 0;\nexport const OPTIONS_DEFAULT_ANIMATION_DURATION = 200;\nexport const OPTIONS_DEFAULT_RANGE = 12;\nexport const OPTIONS_DEFAULT_ITEM_SELECTOR = '#cal-heatmap';\nexport const OPTIONS_DEFAULT_THEME = 'light';\nexport const OPTIONS_DEFAULT_LOCALE = 'en';\n\nexport const SCALE_BASE_OPACITY_COLOR = 'red';\nexport const SCALE_BASE_COLOR_SCHEME = 'YlOrBr';\nexport const SCALE_BASE_COLOR_TYPE = 'quantize';\nexport const SCALE_BASE_COLOR_DOMAIN = [0, 100];\n","// @ts-ignore\nimport { scale } from '@observablehq/plot';\nimport { OptionsType } from './options/Options';\nimport { SCALE_BASE_OPACITY_COLOR } from './constant';\n\nimport type { SubDomain } from './index';\n\ntype ValueType = string | number | undefined;\n\nexport function normalizedScale(scaleOptions: OptionsType['scale']): any {\n try {\n const scaleType = Object.keys(scaleOptions!)[0];\n\n return scale({\n [scaleType]: {\n ...scaleOptions![scaleType as 'color' | 'opacity'],\n clamp: true,\n },\n });\n } catch (error) {\n return null;\n }\n}\n\nfunction scaleStyle(_scale: any, scaleOptions: OptionsType['scale']) {\n const styles: { fill?: Function; 'fill-opacity'?: Function } = {};\n\n if (scaleOptions!.hasOwnProperty('opacity')) {\n styles.fill = () =>\n // eslint-disable-next-line implicit-arrow-linebreak\n scaleOptions!.opacity!.baseColor || SCALE_BASE_OPACITY_COLOR;\n styles['fill-opacity'] = (d: ValueType) => _scale?.apply(d);\n } else {\n styles.fill = (d: ValueType) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n (typeof d === 'string' && d?.startsWith('#') ? d : _scale?.apply(d));\n }\n\n return styles;\n}\n\nexport function applyScaleStyle(\n elem: any,\n _scale: any,\n scaleOptions: OptionsType['scale'],\n keyname?: string,\n) {\n Object.entries(scaleStyle(_scale, scaleOptions)).forEach(([prop, val]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n elem.style(prop, (d: SubDomain | string) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n val(keyname ? (d as SubDomain)[keyname as keyof SubDomain] : d)));\n}\n","'use strict';\nvar $TypeError = TypeError;\nvar MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991\n\nmodule.exports = function (it) {\n if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');\n return it;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar isArray = require('../internals/is-array');\nvar isObject = require('../internals/is-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');\nvar createProperty = require('../internals/create-property');\nvar arraySpeciesCreate = require('../internals/array-species-create');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');\n\n// We can't use this feature detection in V8 since it causes\n// deoptimization and serious performance degradation\n// https://github.com/zloirock/core-js/issues/679\nvar IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {\n var array = [];\n array[IS_CONCAT_SPREADABLE] = false;\n return array.concat()[0] !== array;\n});\n\nvar isConcatSpreadable = function (O) {\n if (!isObject(O)) return false;\n var spreadable = O[IS_CONCAT_SPREADABLE];\n return spreadable !== undefined ? !!spreadable : isArray(O);\n};\n\nvar FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat');\n\n// `Array.prototype.concat` method\n// https://tc39.es/ecma262/#sec-array.prototype.concat\n// with adding support of @@isConcatSpreadable and @@species\n$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n concat: function concat(arg) {\n var O = toObject(this);\n var A = arraySpeciesCreate(O, 0);\n var n = 0;\n var i, k, length, len, E;\n for (i = -1, length = arguments.length; i < length; i++) {\n E = i === -1 ? O : arguments[i];\n if (isConcatSpreadable(E)) {\n len = lengthOfArrayLike(E);\n doesNotExceedSafeInteger(n + len);\n for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);\n } else {\n doesNotExceedSafeInteger(n + 1);\n createProperty(A, n++, E);\n }\n }\n A.length = n;\n return A;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.allSettled` method\n// https://tc39.es/ecma262/#sec-promise.allsettled\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n allSettled: function allSettled(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call(promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = { status: 'fulfilled', value: value };\n --remaining || resolve(values);\n }, function (error) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = { status: 'rejected', reason: error };\n --remaining || resolve(values);\n });\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar create = require('../internals/object-create');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n index: create(null),\n first: undefined,\n last: undefined,\n size: 0\n });\n if (!DESCRIPTORS) that.size = 0;\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n var previous, index;\n // change existing entry\n if (entry) {\n entry.value = value;\n // create new entry\n } else {\n state.last = entry = {\n index: index = fastKey(key, true),\n key: key,\n value: value,\n previous: previous = state.last,\n next: undefined,\n removed: false\n };\n if (!state.first) state.first = entry;\n if (previous) previous.next = entry;\n if (DESCRIPTORS) state.size++;\n else that.size++;\n // add to index\n if (index !== 'F') state.index[index] = entry;\n } return that;\n };\n\n var getEntry = function (that, key) {\n var state = getInternalState(that);\n // fast case\n var index = fastKey(key);\n var entry;\n if (index !== 'F') return state.index[index];\n // frozen object case\n for (entry = state.first; entry; entry = entry.next) {\n if (entry.key === key) return entry;\n }\n };\n\n defineBuiltIns(Prototype, {\n // `{ Map, Set }.prototype.clear()` methods\n // https://tc39.es/ecma262/#sec-map.prototype.clear\n // https://tc39.es/ecma262/#sec-set.prototype.clear\n clear: function clear() {\n var that = this;\n var state = getInternalState(that);\n var data = state.index;\n var entry = state.first;\n while (entry) {\n entry.removed = true;\n if (entry.previous) entry.previous = entry.previous.next = undefined;\n delete data[entry.index];\n entry = entry.next;\n }\n state.first = state.last = undefined;\n if (DESCRIPTORS) state.size = 0;\n else that.size = 0;\n },\n // `{ Map, Set }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.delete\n // https://tc39.es/ecma262/#sec-set.prototype.delete\n 'delete': function (key) {\n var that = this;\n var state = getInternalState(that);\n var entry = getEntry(that, key);\n if (entry) {\n var next = entry.next;\n var prev = entry.previous;\n delete state.index[entry.index];\n entry.removed = true;\n if (prev) prev.next = next;\n if (next) next.previous = prev;\n if (state.first === entry) state.first = next;\n if (state.last === entry) state.last = prev;\n if (DESCRIPTORS) state.size--;\n else that.size--;\n } return !!entry;\n },\n // `{ Map, Set }.prototype.forEach(callbackfn, thisArg = undefined)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.foreach\n // https://tc39.es/ecma262/#sec-set.prototype.foreach\n forEach: function forEach(callbackfn /* , that = undefined */) {\n var state = getInternalState(this);\n var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n var entry;\n while (entry = entry ? entry.next : state.first) {\n boundFunction(entry.value, entry.key, this);\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n }\n },\n // `{ Map, Set}.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-map.prototype.has\n // https://tc39.es/ecma262/#sec-set.prototype.has\n has: function has(key) {\n return !!getEntry(this, key);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `Map.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-map.prototype.get\n get: function get(key) {\n var entry = getEntry(this, key);\n return entry && entry.value;\n },\n // `Map.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-map.prototype.set\n set: function set(key, value) {\n return define(this, key === 0 ? 0 : key, value);\n }\n } : {\n // `Set.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-set.prototype.add\n add: function add(value) {\n return define(this, value = value === 0 ? 0 : value, value);\n }\n });\n if (DESCRIPTORS) defineBuiltInAccessor(Prototype, 'size', {\n configurable: true,\n get: function () {\n return getInternalState(this).size;\n }\n });\n return Constructor;\n },\n setStrong: function (Constructor, CONSTRUCTOR_NAME, IS_MAP) {\n var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n // `{ Map, Set }.prototype.{ keys, values, entries, @@iterator }()` methods\n // https://tc39.es/ecma262/#sec-map.prototype.entries\n // https://tc39.es/ecma262/#sec-map.prototype.keys\n // https://tc39.es/ecma262/#sec-map.prototype.values\n // https://tc39.es/ecma262/#sec-map.prototype-@@iterator\n // https://tc39.es/ecma262/#sec-set.prototype.entries\n // https://tc39.es/ecma262/#sec-set.prototype.keys\n // https://tc39.es/ecma262/#sec-set.prototype.values\n // https://tc39.es/ecma262/#sec-set.prototype-@@iterator\n defineIterator(Constructor, CONSTRUCTOR_NAME, function (iterated, kind) {\n setInternalState(this, {\n type: ITERATOR_NAME,\n target: iterated,\n state: getInternalCollectionState(iterated),\n kind: kind,\n last: undefined\n });\n }, function () {\n var state = getInternalIteratorState(this);\n var kind = state.kind;\n var entry = state.last;\n // revert to the last existing entry\n while (entry && entry.removed) entry = entry.previous;\n // get next entry\n if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n // or finish the iteration\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n // return step by kind\n if (kind === 'keys') return createIterResultObject(entry.key, false);\n if (kind === 'values') return createIterResultObject(entry.value, false);\n return createIterResultObject([entry.key, entry.value], false);\n }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n // `{ Map, Set }.prototype[@@species]` accessors\n // https://tc39.es/ecma262/#sec-get-map-@@species\n // https://tc39.es/ecma262/#sec-get-set-@@species\n setSpecies(CONSTRUCTOR_NAME);\n }\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.es/ecma262/#sec-map-objects\ncollection('Map', function (init) {\n return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","'use strict';\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (O, P) {\n if (!delete O[P]) throw new $TypeError('Cannot delete property ' + tryToString(P) + ' of ' + tryToString(O));\n};\n","'use strict';\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar floor = Math.floor;\n\nvar mergeSort = function (array, comparefn) {\n var length = array.length;\n var middle = floor(length / 2);\n return length < 8 ? insertionSort(array, comparefn) : merge(\n array,\n mergeSort(arraySlice(array, 0, middle), comparefn),\n mergeSort(arraySlice(array, middle), comparefn),\n comparefn\n );\n};\n\nvar insertionSort = function (array, comparefn) {\n var length = array.length;\n var i = 1;\n var element, j;\n\n while (i < length) {\n j = i;\n element = array[i];\n while (j && comparefn(array[j - 1], element) > 0) {\n array[j] = array[--j];\n }\n if (j !== i++) array[j] = element;\n } return array;\n};\n\nvar merge = function (array, left, right, comparefn) {\n var llength = left.length;\n var rlength = right.length;\n var lindex = 0;\n var rindex = 0;\n\n while (lindex < llength || rindex < rlength) {\n array[lindex + rindex] = (lindex < llength && rindex < rlength)\n ? comparefn(left[lindex], right[rindex]) <= 0 ? left[lindex++] : right[rindex++]\n : lindex < llength ? left[lindex++] : right[rindex++];\n } return array;\n};\n\nmodule.exports = mergeSort;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nvar firefox = userAgent.match(/firefox\\/(\\d+)/i);\n\nmodule.exports = !!firefox && +firefox[1];\n","'use strict';\nvar UA = require('../internals/engine-user-agent');\n\nmodule.exports = /MSIE|Trident/.test(UA);\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nvar webkit = userAgent.match(/AppleWebKit\\/(\\d+)\\./);\n\nmodule.exports = !!webkit && +webkit[1];\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar deletePropertyOrThrow = require('../internals/delete-property-or-throw');\nvar toString = require('../internals/to-string');\nvar fails = require('../internals/fails');\nvar internalSort = require('../internals/array-sort');\nvar arrayMethodIsStrict = require('../internals/array-method-is-strict');\nvar FF = require('../internals/engine-ff-version');\nvar IE_OR_EDGE = require('../internals/engine-is-ie-or-edge');\nvar V8 = require('../internals/engine-v8-version');\nvar WEBKIT = require('../internals/engine-webkit-version');\n\nvar test = [];\nvar nativeSort = uncurryThis(test.sort);\nvar push = uncurryThis(test.push);\n\n// IE8-\nvar FAILS_ON_UNDEFINED = fails(function () {\n test.sort(undefined);\n});\n// V8 bug\nvar FAILS_ON_NULL = fails(function () {\n test.sort(null);\n});\n// Old WebKit\nvar STRICT_METHOD = arrayMethodIsStrict('sort');\n\nvar STABLE_SORT = !fails(function () {\n // feature detection can be too slow, so check engines versions\n if (V8) return V8 < 70;\n if (FF && FF > 3) return;\n if (IE_OR_EDGE) return true;\n if (WEBKIT) return WEBKIT < 603;\n\n var result = '';\n var code, chr, value, index;\n\n // generate an array with more 512 elements (Chakra and old V8 fails only in this case)\n for (code = 65; code < 76; code++) {\n chr = String.fromCharCode(code);\n\n switch (code) {\n case 66: case 69: case 70: case 72: value = 3; break;\n case 68: case 71: value = 4; break;\n default: value = 2;\n }\n\n for (index = 0; index < 47; index++) {\n test.push({ k: chr + index, v: value });\n }\n }\n\n test.sort(function (a, b) { return b.v - a.v; });\n\n for (index = 0; index < test.length; index++) {\n chr = test[index].k.charAt(0);\n if (result.charAt(result.length - 1) !== chr) result += chr;\n }\n\n return result !== 'DGBEFHACIJK';\n});\n\nvar FORCED = FAILS_ON_UNDEFINED || !FAILS_ON_NULL || !STRICT_METHOD || !STABLE_SORT;\n\nvar getSortCompare = function (comparefn) {\n return function (x, y) {\n if (y === undefined) return -1;\n if (x === undefined) return 1;\n if (comparefn !== undefined) return +comparefn(x, y) || 0;\n return toString(x) > toString(y) ? 1 : -1;\n };\n};\n\n// `Array.prototype.sort` method\n// https://tc39.es/ecma262/#sec-array.prototype.sort\n$({ target: 'Array', proto: true, forced: FORCED }, {\n sort: function sort(comparefn) {\n if (comparefn !== undefined) aCallable(comparefn);\n\n var array = toObject(this);\n\n if (STABLE_SORT) return comparefn === undefined ? nativeSort(array) : nativeSort(array, comparefn);\n\n var items = [];\n var arrayLength = lengthOfArrayLike(array);\n var itemsLength, index;\n\n for (index = 0; index < arrayLength; index++) {\n if (index in array) push(items, array[index]);\n }\n\n internalSort(items, getSortCompare(comparefn));\n\n itemsLength = lengthOfArrayLike(items);\n index = 0;\n\n while (index < itemsLength) array[index] = items[index++];\n while (index < arrayLength) deletePropertyOrThrow(array, index++);\n\n return array;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar $includes = require('../internals/array-includes').includes;\nvar fails = require('../internals/fails');\nvar addToUnscopables = require('../internals/add-to-unscopables');\n\n// FF99+ bug\nvar BROKEN_ON_SPARSE = fails(function () {\n // eslint-disable-next-line es/no-array-prototype-includes -- detection\n return !Array(1).includes();\n});\n\n// `Array.prototype.includes` method\n// https://tc39.es/ecma262/#sec-array.prototype.includes\n$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE }, {\n includes: function includes(el /* , fromIndex = 0 */) {\n return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('includes');\n","'use strict';\nvar $ = require('../internals/export');\nvar $map = require('../internals/array-iteration').map;\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('map');\n\n// `Array.prototype.map` method\n// https://tc39.es/ecma262/#sec-array.prototype.map\n// with adding support of @@species\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n map: function map(callbackfn /* , thisArg */) {\n return $map(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar $filter = require('../internals/array-iteration').filter;\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\n\nvar HAS_SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('filter');\n\n// `Array.prototype.filter` method\n// https://tc39.es/ecma262/#sec-array.prototype.filter\n// with adding support of @@species\n$({ target: 'Array', proto: true, forced: !HAS_SPECIES_SUPPORT }, {\n filter: function filter(callbackfn /* , thisArg */) {\n return $filter(this, callbackfn, arguments.length > 1 ? arguments[1] : undefined);\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar iteratorClose = require('../internals/iterator-close');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n try {\n return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar toObject = require('../internals/to-object');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar isConstructor = require('../internals/is-constructor');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $Array = Array;\n\n// `Array.from` method implementation\n// https://tc39.es/ecma262/#sec-array.from\nmodule.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n var O = toObject(arrayLike);\n var IS_CONSTRUCTOR = isConstructor(this);\n var argumentsLength = arguments.length;\n var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n var mapping = mapfn !== undefined;\n if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined);\n var iteratorMethod = getIteratorMethod(O);\n var index = 0;\n var length, result, step, iterator, next, value;\n // if the target is not iterable or it's an array with the default iterator - use a simple case\n if (iteratorMethod && !(this === $Array && isArrayIteratorMethod(iteratorMethod))) {\n iterator = getIterator(O, iteratorMethod);\n next = iterator.next;\n result = IS_CONSTRUCTOR ? new this() : [];\n for (;!(step = call(next, iterator)).done; index++) {\n value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;\n createProperty(result, index, value);\n }\n } else {\n length = lengthOfArrayLike(O);\n result = IS_CONSTRUCTOR ? new this(length) : $Array(length);\n for (;length > index; index++) {\n value = mapping ? mapfn(O[index], index) : O[index];\n createProperty(result, index, value);\n }\n }\n result.length = index;\n return result;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar from = require('../internals/array-from');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\n\nvar INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {\n // eslint-disable-next-line es/no-array-from -- required for testing\n Array.from(iterable);\n});\n\n// `Array.from` method\n// https://tc39.es/ecma262/#sec-array.from\n$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {\n from: from\n});\n","'use strict';\n// a string of all valid unicode whitespaces\nmodule.exports = '\\u0009\\u000A\\u000B\\u000C\\u000D\\u0020\\u00A0\\u1680\\u2000\\u2001\\u2002' +\n '\\u2003\\u2004\\u2005\\u2006\\u2007\\u2008\\u2009\\u200A\\u202F\\u205F\\u3000\\u2028\\u2029\\uFEFF';\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar toString = require('../internals/to-string');\nvar whitespaces = require('../internals/whitespaces');\n\nvar replace = uncurryThis(''.replace);\nvar ltrim = RegExp('^[' + whitespaces + ']+');\nvar rtrim = RegExp('(^|[^' + whitespaces + '])[' + whitespaces + ']+$');\n\n// `String.prototype.{ trim, trimStart, trimEnd, trimLeft, trimRight }` methods implementation\nvar createMethod = function (TYPE) {\n return function ($this) {\n var string = toString(requireObjectCoercible($this));\n if (TYPE & 1) string = replace(string, ltrim, '');\n if (TYPE & 2) string = replace(string, rtrim, '$1');\n return string;\n };\n};\n\nmodule.exports = {\n // `String.prototype.{ trimLeft, trimStart }` methods\n // https://tc39.es/ecma262/#sec-string.prototype.trimstart\n start: createMethod(1),\n // `String.prototype.{ trimRight, trimEnd }` methods\n // https://tc39.es/ecma262/#sec-string.prototype.trimend\n end: createMethod(2),\n // `String.prototype.trim` method\n // https://tc39.es/ecma262/#sec-string.prototype.trim\n trim: createMethod(3)\n};\n","'use strict';\nvar PROPER_FUNCTION_NAME = require('../internals/function-name').PROPER;\nvar fails = require('../internals/fails');\nvar whitespaces = require('../internals/whitespaces');\n\nvar non = '\\u200B\\u0085\\u180E';\n\n// check that a method works with the correct list\n// of whitespaces and has a correct name\nmodule.exports = function (METHOD_NAME) {\n return fails(function () {\n return !!whitespaces[METHOD_NAME]()\n || non[METHOD_NAME]() !== non\n || (PROPER_FUNCTION_NAME && whitespaces[METHOD_NAME].name !== METHOD_NAME);\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar $trim = require('../internals/string-trim').trim;\nvar forcedStringTrimMethod = require('../internals/string-trim-forced');\n\n// `String.prototype.trim` method\n// https://tc39.es/ecma262/#sec-string.prototype.trim\n$({ target: 'String', proto: true, forced: forcedStringTrimMethod('trim') }, {\n trim: function trim() {\n return $trim(this);\n }\n});\n","import { Position } from '../constant';\nimport type CalHeatmap from '../CalHeatmap';\nimport type { Timestamp, SubDomain } from '../index';\n\nexport const DEFAULT_SELECTOR = '.ch-subdomain';\nconst HIGHLIGHT_CLASSNAME = 'highlight';\n\nexport default class SubDomainPainter {\n calendar: CalHeatmap;\n\n root: any;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.root = null;\n }\n\n paint(root: any): void {\n this.root = root || this.root;\n const containerClassname = `${DEFAULT_SELECTOR}-container`;\n\n const subDomainSvgGroup = this.root\n .selectAll(containerClassname)\n .data(\n (d: Timestamp) => [d],\n (d: Timestamp) => d,\n )\n .join(\n (enter: any) => enter\n .append('svg')\n .call((selection: any) => this.#setPositions(selection))\n .attr('class', containerClassname.slice(1)),\n\n (update: any) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n update.call((selection: any) => this.#setPositions(selection)),\n );\n\n const {\n subDomain: {\n radius, width, height, sort,\n },\n } = this.calendar.options.options;\n const evt = this.calendar.eventEmitter;\n\n subDomainSvgGroup\n .selectAll('g')\n .data((d: Timestamp) => {\n const subDomainsCollection: SubDomain[] =\n this.calendar.domainCollection.get(d)!;\n if (sort === 'desc') {\n const max = Math.max(\n ...subDomainsCollection.map((s: SubDomain) => s.x),\n );\n subDomainsCollection.forEach((s: SubDomain, i: number) => {\n subDomainsCollection[i].x = Math.abs(s.x - max);\n });\n }\n\n return subDomainsCollection;\n })\n .join(\n (enter: any) => enter\n .append('g')\n .call((selection: any) => selection\n .insert('rect')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-bg`))\n .attr('width', width)\n .attr('height', height)\n .attr('x', (d: SubDomain) => this.#getX(d))\n .attr('y', (d: SubDomain) => this.#getY(d))\n .on('click', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('click', ev, d.t, d.v))\n .on('mouseover', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('mouseover', ev, d.t, d.v))\n .on('mouseout', (ev: PointerEvent, d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n evt.emit('mouseout', ev, d.t, d.v))\n .attr('rx', radius > 0 ? radius : null)\n .attr('ry', radius > 0 ? radius : null))\n .call((selection: any) => this.#appendText(selection)),\n (update: any) => update\n .selectAll('rect')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-bg`))\n .attr('width', width)\n .attr('height', height)\n .attr('x', (d: SubDomain) => this.#getX(d))\n .attr('y', (d: SubDomain) => this.#getY(d))\n .attr('rx', radius)\n .attr('ry', radius),\n );\n }\n\n /**\n * Set the subDomain group X and Y position\n * @param {d3-selection} selection A d3-selection object\n */\n #setPositions(selection: any): void {\n const { options } = this.calendar.options;\n const {\n padding,\n label: { position },\n } = options.domain;\n\n selection\n .attr('x', () => {\n let pos = padding[Position.LEFT];\n if (position === 'left') {\n pos += options.x.domainHorizontalLabelWidth;\n }\n return pos;\n })\n .attr('y', () => {\n let pos = padding[Position.TOP];\n if (position === 'top') {\n pos += options.x.domainVerticalLabelHeight;\n }\n return pos;\n });\n }\n\n /**\n * Return a classname if the specified date should be highlighted\n *\n * @param {number} timestamp Unix timestamp of the current subDomain\n * @return {String} the highlight class\n */\n #classname(timestamp: Timestamp, ...otherClasses: string[]): string {\n const {\n date: { highlight },\n subDomain: { type },\n } = this.calendar.options.options;\n let classname = '';\n\n if (highlight.length > 0) {\n highlight.forEach((d) => {\n const unitFn = this.calendar.templateCollection.get(type).extractUnit;\n\n if (unitFn(+d) === unitFn(timestamp)) {\n classname = HIGHLIGHT_CLASSNAME;\n }\n });\n }\n\n return [classname, ...otherClasses].join(' ').trim();\n }\n\n #appendText(elem: any) {\n const { width, height, label } = this.calendar.options.options.subDomain;\n\n if (!label) {\n return null;\n }\n\n return elem\n .append('text')\n .attr('class', (d: SubDomain) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#classname(d.t, `${DEFAULT_SELECTOR.slice(1)}-text`))\n .attr('x', (d: SubDomain) => this.#getX(d) + width / 2)\n .attr('y', (d: SubDomain) => this.#getY(d) + height / 2)\n .attr('text-anchor', 'middle')\n .attr('dominant-baseline', 'central')\n .text((d: SubDomain, i: number, nodes: any[]) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.calendar.dateHelper.format(d.t, label, d.v, nodes[i]));\n }\n\n #getCoordinates(axis: 'x' | 'y', d: SubDomain): number {\n const { subDomain } = this.calendar.options.options;\n return (\n d[axis] *\n (subDomain[axis === 'x' ? 'width' : 'height'] + subDomain.gutter)\n );\n }\n\n #getX(d: SubDomain): number {\n return this.#getCoordinates('x', d);\n }\n\n #getY(d: SubDomain): number {\n return this.#getCoordinates('y', d);\n }\n}\n","import { select, create } from 'd3-selection';\nimport { normalizedScale, applyScaleStyle } from '../scale';\nimport { DEFAULT_SELECTOR as MAIN_SELECTOR } from '../calendar/CalendarPainter';\nimport {\n // force line break from prettier\n DEFAULT_SELECTOR as SUBDOMAIN_SELECTOR,\n} from '../subDomain/SubDomainPainter';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport type { IPlugin, PluginOptions } from '../index';\nimport {\n OPTIONS_DEFAULT_SUBDOMAIN_WIDTH,\n OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT,\n OPTIONS_DEFAULT_SUBDOMAIN_GUTTER,\n OPTIONS_DEFAULT_SUBDOMAIN_RADIUS,\n} from '../constant';\n\ninterface LegendOptions extends PluginOptions {\n enabled: boolean;\n itemSelector: string | null;\n width: number;\n height: number;\n radius: number;\n gutter: number;\n includeBlank: boolean;\n}\n\nconst DEFAULT_SELECTOR = '.ch-plugin-legend-lite';\n\nconst defaultOptions: LegendOptions = {\n enabled: true, // Whether to display the legend\n itemSelector: null,\n width: OPTIONS_DEFAULT_SUBDOMAIN_WIDTH,\n height: OPTIONS_DEFAULT_SUBDOMAIN_HEIGHT,\n gutter: OPTIONS_DEFAULT_SUBDOMAIN_GUTTER,\n radius: OPTIONS_DEFAULT_SUBDOMAIN_RADIUS,\n includeBlank: false,\n};\n\nexport default class LegendLite implements IPlugin {\n name = 'LegendLite';\n\n calendar: CalHeatmap;\n\n root: any;\n\n shown: boolean;\n\n options: LegendOptions;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.root = null;\n this.shown = false;\n this.options = defaultOptions;\n }\n\n setup(pluginOptions?: Partial): void {\n this.options = { ...this.options, ...pluginOptions };\n }\n\n paint(): Promise {\n const { enabled, itemSelector } = this.options;\n\n if (!enabled || (itemSelector && select(itemSelector).empty())) {\n return this.destroy();\n }\n\n this.shown = true;\n\n this.root = select(\n itemSelector || this.calendar.options.options.itemSelector,\n );\n\n if (this.root.select(DEFAULT_SELECTOR).empty()) {\n this.root = this.root\n .append('div')\n .attr('class', DEFAULT_SELECTOR.slice(1));\n } else {\n this.root = this.root.select(DEFAULT_SELECTOR);\n }\n\n const node = this.#buildLegend();\n\n this.root.selectAll('*').remove();\n this.root.append(() => node.node());\n\n return Promise.resolve();\n }\n\n destroy(): Promise {\n if (this.root !== null) {\n this.root.remove();\n this.root = null;\n }\n\n return Promise.resolve();\n }\n\n #buildLegend() {\n const node = create('svg');\n const scale = normalizedScale(this.calendar.options.options.scale);\n const {\n width, height, gutter, includeBlank,\n } = this.options;\n\n const localRange = [...scale.range];\n if (includeBlank) {\n localRange.unshift(null);\n }\n\n node\n .attr('class', MAIN_SELECTOR.slice(1))\n .attr(\n 'width',\n localRange.length * width + (localRange.length - 1) * gutter,\n )\n .attr('height', height);\n\n node\n .selectAll('rect')\n .data(localRange)\n .join(\n (enter: any) => enter.append('rect').call((sc: any) =>\n // eslint-disable-next-line implicit-arrow-linebreak\n this.#nodeAttrs(sc, scale)),\n (update: any) => update\n .selectAll('rect')\n .call((sc: any) => this.#nodeAttrs(sc, scale)),\n );\n\n return node;\n }\n\n #nodeAttrs(selection: any, scale: any) {\n const {\n width, height, radius, gutter,\n } = this.options;\n\n return selection\n .attr('width', width)\n .attr('height', height)\n .attr('class', `${SUBDOMAIN_SELECTOR.slice(1)}-bg`)\n .attr('rx', radius)\n .attr('ry', radius)\n .attr('x', (_d: any, i: number) => i * (width + gutter))\n .attr('y', 0)\n .call((element: any) => {\n applyScaleStyle(element, scale, this.calendar.options.options.scale!);\n });\n }\n}\n","import { select } from 'd3-selection';\n\nimport DomainsContainerPainter from '../domain/DomainsContainerPainter';\nimport PluginPainter from '../plugins/PluginPainter';\n\nimport type CalHeatmap from '../CalHeatmap';\nimport { ScrollDirection } from '../constant';\nimport type { Dimensions } from '../index';\n\nexport const DEFAULT_SELECTOR = '.ch-container';\n\nexport default class CalendarPainter {\n calendar: CalHeatmap;\n\n dimensions: Dimensions;\n\n root: any;\n\n domainsContainerPainter: DomainsContainerPainter;\n\n pluginPainter: PluginPainter;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.dimensions = {\n width: 0,\n height: 0,\n };\n this.root = null;\n this.domainsContainerPainter = new DomainsContainerPainter(calendar);\n this.pluginPainter = new PluginPainter(calendar);\n }\n\n setup(): boolean {\n const { itemSelector, theme } = this.calendar.options.options;\n\n if (!this.root) {\n this.root = select(itemSelector)\n .append('svg')\n .attr('data-theme', theme)\n .attr('class', DEFAULT_SELECTOR.slice(1));\n this.domainsContainerPainter.setup();\n }\n\n this.calendar.pluginManager.setupAll();\n\n return true;\n }\n\n paint(navigationDir: ScrollDirection = ScrollDirection.SCROLL_NONE) {\n const transitions = this.domainsContainerPainter\n .paint(navigationDir)\n .concat(this.pluginPainter.paint())\n .concat(this.domainsContainerPainter.updatePosition());\n\n this.#resize();\n\n return Promise.allSettled(transitions);\n }\n\n #getHeight(): Dimensions['height'] {\n return (\n this.domainsContainerPainter.height() + this.pluginPainter.insideHeight()\n );\n }\n\n #getWidth(): Dimensions['width'] {\n return (\n this.domainsContainerPainter.width() + this.pluginPainter.insideWidth()\n );\n }\n\n #resize(): void {\n const { options } = this.calendar.options;\n\n const newWidth = this.#getWidth();\n const newHeight = this.#getHeight();\n\n this.root\n .transition()\n .duration(options.animationDuration)\n .attr('width', newWidth)\n .attr('height', newHeight);\n\n if (\n newWidth !== this.dimensions.width ||\n newHeight !== this.dimensions.height\n ) {\n this.calendar.eventEmitter.emit(\n 'resize',\n newWidth,\n newHeight,\n this.dimensions.width,\n this.dimensions.height,\n );\n }\n\n this.dimensions = {\n width: newWidth,\n height: newHeight,\n };\n }\n\n destroy(): Promise {\n const result: Promise[] = this.calendar.pluginManager\n .destroyAll()\n .concat(this.domainsContainerPainter.destroy());\n\n if (!this.root) {\n return Promise.allSettled(result);\n }\n\n result.push(\n this.root\n .transition()\n .duration(this.calendar.options.options.animationDuration)\n .attr('width', 0)\n .attr('height', 0)\n .remove()\n .end(),\n );\n\n return Promise.allSettled(result);\n }\n}\n"],"names":["fails","exec","error","descriptors","require$$0","Object","defineProperty","get","functionBindNative","test","bind","hasOwnProperty","NATIVE_BIND","FunctionPrototype","Function","prototype","call","uncurryThisWithBind","functionUncurryThis","fn","apply","arguments","isNullOrUndefined","it","$TypeError","TypeError","requireObjectCoercible","$Object","toObject","argument","require$$1","hasOwnProperty_1","hasOwn","key","DESCRIPTORS","getDescriptor","getOwnPropertyDescriptor","EXISTS","functionName","PROPER","name","CONFIGURABLE","configurable","makeBuiltIn$3","exports","documentAll","document","all","documentAll_1","IS_HTMLDDA","undefined","isCallable","check","Math","global","globalThis","window","self","this","defineGlobalProperty","value","writable","SHARED","sharedStore","store","require$$2","functionToString","toString","inspectSource","match","version","WeakMap","weakMapBasicDetection","String","isObject","objectDefineProperty","createElement","documentCreateElement","ie8DomDefine","a","v8PrototypeDefineBug","$String","anObject","functionCall","getBuiltIn","namespace","method","length","objectIsPrototypeOf","isPrototypeOf","engineUserAgent","navigator","userAgent","process","Deno","versions","v8","split","engineV8Version","V8_VERSION","symbolConstructorDetection","getOwnPropertySymbols","symbol","Symbol","sham","useSymbolAsUid","iterator","isSymbol","require$$3","$Symbol","tryToString","aCallable","getMethod","V","P","func","shared$3","sharedModule","push","mode","copyright","license","source","uncurryThis","id","postfix","random","uid","shared","NATIVE_SYMBOL","require$$4","USE_SYMBOL_AS_UID","require$$5","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","wellKnownSymbol","ordinaryToPrimitive","input","pref","val","valueOf","TO_PRIMITIVE","toPrimitive","result","exoticToPrim","toPropertyKey","IE8_DOM_DEFINE","V8_PROTOTYPE_DEFINE_BUG","$defineProperty","$getOwnPropertyDescriptor","ENUMERABLE","WRITABLE","f","O","Attributes","current","enumerable","set","has","createPropertyDescriptor","bitmap","definePropertyModule","createNonEnumerableProperty","object","keys","sharedKey","hiddenKeys","NATIVE_WEAK_MAP","require$$6","require$$7","OBJECT_ALREADY_INITIALIZED","state","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","CONFIGURABLE_FUNCTION_NAME","enforceInternalState","getInternalState","stringSlice","slice","replace","join","CONFIGURABLE_LENGTH","TEMPLATE","makeBuiltIn","makeBuiltInModule","options","getter","setter","arity","constructor","defineBuiltInAccessor","target","descriptor","FUNCTION_NAME_EXISTS","nameRE","regExpExec","objectGetOwnPropertyDescriptor","objectPropertyIsEnumerable","$propertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","classofRaw","classof","indexedObject","IndexedObject","toIndexedObject","propertyIsEnumerableModule","defineBuiltIn","simple","unsafe","nonConfigurable","nonWritable","ceil","floor","trunc","x","n","toIntegerOrInfinity","number","max","min","toAbsoluteIndex","index","integer","toLength","lengthOfArrayLike","obj","createMethod","IS_INCLUDES","$this","el","fromIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","i","enumBugKeys","internalObjectKeys","concat","objectGetOwnPropertyNames","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","ownKeys","getOwnPropertyDescriptorModule","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","toLowerCase","isForced_1","copyConstructorProperties","exceptions","_export","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","objectKeys","require$$8","$assign","assign","objectAssign","b","A","B","alphabet","forEach","chr","T","argumentsLength","S","j","toStringTagSupport","TO_STRING_TAG_SUPPORT","TO_STRING_TAG","CORRECT_ARGUMENTS","tag","tryGet","callee","engineIsNode","uncurryThisAccessor","aPossiblePrototype","objectSetPrototypeOf","setPrototypeOf","CORRECT_SETTER","Array","proto","__proto__","setToStringTag","TAG","SPECIES","setSpecies","CONSTRUCTOR_NAME","Constructor","anInstance","Prototype","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","$location","defer","channel","port","isConstructor","called","aConstructor","functionApply","Reflect","functionUncurryThisClause","functionBindContext","that","html","arraySlice","engineIsIos","validateArgumentsLength","passed","required","IS_IOS","require$$10","IS_NODE","require$$11","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","location","run","runner","eventListener","event","globalPostMessageDefer","postMessage","protocol","host","handler","args","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","task","Queue","head","tail","add","item","entry","next","notify","toggle","node","promise","then","engineIsIosPebble","Pebble","engineIsWebosWebkit","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","Promise","queueMicrotaskDescriptor","microtask","flush","parent","domain","exit","enter","resolve","createTextNode","observe","characterData","microtask_1","perform","promiseNativeConstructor","engineIsDeno","engineIsBrowser","NativePromiseConstructor","IS_BROWSER","IS_DENO","require$$9","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","promiseConstructorDetection","CONSTRUCTOR","REJECTION_EVENT","newPromiseCapability$2","PromiseCapability","C","reject","$$resolve","$$reject","newPromiseCapability","Internal","OwnPromiseCapability","nativeThen","$","require$$12","speciesConstructor","defaultConstructor","require$$14","require$$15","hostReportErrors","console","require$$17","require$$18","InternalStateModule","require$$19","require$$20","newPromiseCapabilityModule","require$$22","PROMISE","require$$21","NATIVE_PROMISE_SUBCLASSING","getInternalPromiseState","setInternalState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","isThenable","callReaction","reaction","exited","ok","fail","rejection","onHandleUnhandled","isReject","notified","reactions","onUnhandled","reason","initEvent","isUnhandled","emit","unwrap","internalReject","done","internalResolve","wrapper","executor","onFulfilled","onRejected","PromiseWrapper","wrap","iterators","Iterators","ITERATOR","ArrayPrototype","isArrayIteratorMethod","getIteratorMethod","getIterator","usingIterator","iteratorMethod","iteratorClose","kind","innerResult","innerError","Result","stopped","ResultPrototype","iterate","iterable","unboundFunction","iterFn","step","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","SAFE_CLOSING","iteratorWithReturn","return","from","checkCorrectnessOfIteration","SKIP_CLOSING","ITERATION_SUPPORT","promiseStaticsIncorrectIteration","capability","$promiseResolve","values","remaining","alreadyCalled","real","catch","race","r","promiseResolve","promiseCapability","objectDefineProperties","defineProperties","Properties","props","activeXDocument","definePropertiesModule","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","style","display","src","contentWindow","open","F","objectCreate","create","UNSCOPABLES","IteratorPrototype","PrototypeOfArrayIteratorPrototype","arrayIterator","addToUnscopables","correctPrototypeGetter","getPrototypeOf","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","objectGetPrototypeOf","BUGGY_SAFARI_ITERATORS","NEW_ITERATOR_PROTOTYPE","iteratorsCore","returnThis","createIteratorConstructor","IteratorConstructor","NAME","ENUMERABLE_NEXT","PROPER_FUNCTION_NAME","require$$13","KEYS","VALUES","ENTRIES","iteratorDefine","Iterable","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","createIterResultObject","defineIterator","ARRAY_ITERATOR","es_array_iterator","iterated","Arguments","charAt","charCodeAt","CONVERT_TO_STRING","pos","first","second","position","size","codeAt","STRING_ITERATOR","point","internalMetadata","objectGetOwnPropertyNamesExternal","createProperty","propertyKey","$Array","arraySliceSimple","start","end","k","fin","$getOwnPropertyNames","windowNames","getWindowNames","arrayBufferNonExtensible","ArrayBuffer","buffer","isExtensible","ARRAY_BUFFER_NON_EXTENSIBLE","$isExtensible","objectIsExtensible","freezing","preventExtensions","getOwnPropertyNamesExternalModule","FREEZING","REQUIRED","METADATA","setMetadata","objectID","weakData","meta","internalMetadataModule","enable","splice","fastKey","getWeakData","onFreeze","InternalMetadataModule","inheritIfRequired","dummy","Wrapper","NewTarget","NewTargetPrototype","collection","common","IS_MAP","IS_WEAK","ADDER","NativeConstructor","NativePrototype","exported","fixMethod","uncurriedNativeMethod","getConstructor","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","setStrong","defineBuiltIns","isArray","arraySpeciesConstructor","originalArray","arraySpeciesCreate","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_REJECT","NO_HOLES","callbackfn","specificCreate","boundFunction","arrayIteration","map","filter","some","every","find","findIndex","filterReject","internalStateGetterFor","uncaughtFrozenStore","frozen","UncaughtFrozenStore","findUncaughtFrozen","delete","collectionWeak","define","init","domIterables","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DOMTokenList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","classList","DOMTokenListPrototype","domTokenListPrototype","DOMIterables","ArrayIteratorMethods","ArrayValues","handlePrototype","CollectionPrototype","COLLECTION_NAME","METHOD_NAME","arrayMethodHasSpeciesSupport","array","foo","Boolean","nativeSlice","HAS_SPECIES_SUPPORT","arrayMethodIsStrict","nativeJoin","__classPrivateFieldGet","receiver","separator","nativeKeys","MATCH","isRegExp","notARegExp","correctIsRegExpLogic","regexp","error1","error2","nativeStartsWith","startsWith","CORRECT_IS_REGEXP_LOGIC","searchString","search","$forEach","arrayForEach","IE_BUG","TO_ENTRIES","IE_WORKAROUND","$entries","defined","Number","isNaN","ascendingDefined","ascending","finite","isFinite","NaN","positive","negative","re","parse","fallback","Date","timeIntervals","Map","timeSecond","timeMinute","timeHour","timeDay","timeWeek","timeMonth","timeYear","timeMonday","timeTuesday","timeWednesday","timeThursday","timeFriday","timeSaturday","timeSunday","utcIntervals","utcSecond","utcMinute","utcHour","utcDay","utcWeek","utcMonth","utcYear","utcMonday","utcTuesday","utcWednesday","utcThursday","utcFriday","utcSaturday","utcSunday","maybeTimeInterval","interval","Error","maybeUtcInterval","TypedArray","Uint8Array","objectToString","constant","coerceNumbers","coerceNumber","Float64Array","coerceDates","coerceDate","isoParse","arrayify","isScaleOptions","option","maybeInterval","isInteger","abs","d","offset","range","lo","hi","rangei","maybeRangeInterval","isOrdinal","isTemporal","isTemporalString","isNumericString","trim","orderof","last","descending","color","radius","opacity","registry","sqrt4_3","sqrt","symbolHexagon","draw","context","rx","PI","ry","hy","moveTo","lineTo","closePath","symbols","symbolAsterisk","symbolCircle","symbolCross","symbolDiamond","symbolDiamond2","symbolPlus","symbolSquare","symbolSquare2","symbolStar","symbolTimes","symbolTriangle","symbolTriangle2","symbolWye","maybeSymbol","isSymbolObject","warn","message","ordinalSchemes","schemeAccent","schemeCategory10","schemeDark2","schemePaired","schemePastel1","schemePastel2","schemeSet1","schemeSet2","schemeSet3","schemeTableau10","scheme11","schemeBrBG","interpolateBrBG","schemePRGn","interpolatePRGn","schemePiYG","interpolatePiYG","schemePuOr","interpolatePuOr","schemeRdBu","interpolateRdBu","schemeRdGy","interpolateRdGy","schemeRdYlBu","interpolateRdYlBu","schemeRdYlGn","interpolateRdYlGn","schemeSpectral","interpolateSpectral","scheme11r","scheme9","schemeBlues","interpolateBlues","schemeGreens","interpolateGreens","schemeGreys","interpolateGreys","schemeOranges","interpolateOranges","schemePurples","interpolatePurples","schemeReds","interpolateReds","schemei","interpolateTurbo","interpolateViridis","interpolateMagma","interpolateInferno","interpolatePlasma","interpolateCividis","interpolateCubehelixDefault","interpolateWarm","interpolateCool","schemeBuGn","interpolateBuGn","schemeBuPu","interpolateBuPu","schemeGnBu","interpolateGnBu","schemeOrRd","interpolateOrRd","schemePuBu","interpolatePuBu","schemePuBuGn","interpolatePuBuGn","schemePuRd","interpolatePuRd","schemeRdPu","interpolateRdPu","schemeYlGn","interpolateYlGn","schemeYlGnBu","interpolateYlGnBu","schemeYlOrBr","interpolateYlOrBr","schemeYlOrRd","interpolateYlOrRd","schemeicyclical","interpolateRainbow","interpolateSinebow","scheme","interpolate","quantize","t","reverse","ordinalScheme","s","ordinalRange","quantitativeSchemes","quantitativeScheme","divergingSchemes","Set","isDivergingScheme","flip","unit","interpolators","interpolateNumber","interpolateRgb","interpolateHsl","interpolateHcl","interpolateLab","maybeInterpolator","createScaleQ","scale","channels","nice","clamp","zero","inferAutoDomain","unknown","round","inferRadialRange","inferLengthRange","interpolateRound","_","interpolatePiecewise","extent","sign","reverseof","maybeNiceInterval","maybeNice","createScalePow","exponent","scalePow","createScaleThreshold","isOrdered","scaleThreshold","inferDomain","inferZeroDomain","hint","h25","quantile","h50","median","inferLogDomain","v","inferQuantileDomain","createScaleD","transform","pivot","symmetric","piecewise","mid","mindelta","maxdelta","invert","interpolator","createScaleDivergingPow","scaleDivergingPow","transformSqrt","pow","transformPow","createScaleDivergingSymlog","scaleDivergingSymlog","log1p","expm1","transformSymlog","transformIdentity","transformLog","log","exp","createScaleT","ordinalImplicit","createScaleO","createScaleOrdinal","fill","inferHint","stroke","inferSymbolHint","isNone","symbolsStroke","symbolsFill","inferSymbolRange","maybeBooleanRange","t0","scaleImplicit","scaleOrdinal","maybeRound","InternSet","sort","candidate","normalizeScale","projection","typeProjection","asOrdinalType","inferScaleType","isOrdinalScale","formatScaleType","coerceType","coerceSymbols","scaleDiverging","createScaleDiverging","createScaleDivergingSqrt","base","scaleDivergingLog","createScaleDivergingLog","scaleLinear","createScaleLinear","createScaleSqrt","quantiles","scaleQuantile","createScaleQuantile","thresholds","ticks","pop","createScaleQuantize","scaleLog","createScaleLog","scaleSymlog","createScaleSymlog","scaleUtc","createScaleUtc","scaleTime","createScaleTime","align","padding","scalePoint","createScalePoint","paddingInner","paddingOuter","scaleBand","createScaleBand","scaleIdentity","createScale","description","coerceValues","c","exposeScale","percent","bandwidth","ScrollDirection","Position","SCALE_BASE_OPACITY_COLOR","normalizedScale","scaleOptions","scaleType","applyScaleStyle","elem","_scale","keyname","styles","baseColor","scaleStyle","_ref","_ref2","_slicedToArray","prop","doesNotExceedSafeInteger","IS_CONCAT_SPREADABLE","IS_CONCAT_SPREADABLE_SUPPORT","isConcatSpreadable","spreadable","arg","len","E","allSettled","status","collectionStrong","previous","getEntry","removed","prev","ITERATOR_NAME","getInternalCollectionState","getInternalIteratorState","mergeSort","comparefn","middle","insertionSort","merge","element","left","right","llength","rlength","lindex","rindex","arraySort","firefox","engineFfVersion","engineIsIeOrEdge","webkit","engineWebkitVersion","deletePropertyOrThrow","internalSort","FF","IE_OR_EDGE","V8","WEBKIT","nativeSort","FAILS_ON_UNDEFINED","FAILS_ON_NULL","STRICT_METHOD","STABLE_SORT","code","fromCharCode","itemsLength","items","arrayLength","y","getSortCompare","$includes","$map","$filter","callWithSafeIterationClosing","arrayLike","IS_CONSTRUCTOR","mapfn","mapping","whitespaces","ltrim","RegExp","rtrim","stringTrim","$trim","forcedStringTrimMethod","DEFAULT_SELECTOR","defaultOptions","enabled","itemSelector","width","height","gutter","includeBlank","LegendLite","calendar","_classCallCheck","root","shown","pluginOptions","_this$options","select","destroy","append","attr","selectAll","remove","_this$options2","localRange","_toConsumableArray","unshift","sc","_this","_LegendLite_instances","_LegendLite_nodeAttrs","update","selection","_this2","_this$options3","_d"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199]} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.esm.js b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.esm.js new file mode 100644 index 0000000..37b15dc --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.esm.js @@ -0,0 +1,3768 @@ +import { createPopper } from '@popperjs/core'; + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } +} +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; +} +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); +} +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + return arr2; +} +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); +} +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); +} + +var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + +var check = function (it) { + return it && it.Math === Math && it; +}; + +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +var global$j = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + +var objectGetOwnPropertyDescriptor = {}; + +var fails$j = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } +}; + +var fails$i = fails$j; + +// Detect IE8's incomplete defineProperty implementation +var descriptors = !fails$i(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; +}); + +var fails$h = fails$j; + +var functionBindNative = !fails$h(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); +}); + +var NATIVE_BIND$3 = functionBindNative; + +var call$e = Function.prototype.call; + +var functionCall = NATIVE_BIND$3 ? call$e.bind(call$e) : function () { + return call$e.apply(call$e, arguments); +}; + +var objectPropertyIsEnumerable = {}; + +var $propertyIsEnumerable = {}.propertyIsEnumerable; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor; + +// Nashorn ~ JDK8 bug +var NASHORN_BUG = getOwnPropertyDescriptor$2 && !$propertyIsEnumerable.call({ 1: 2 }, 1); + +// `Object.prototype.propertyIsEnumerable` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable +objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor$2(this, V); + return !!descriptor && descriptor.enumerable; +} : $propertyIsEnumerable; + +var createPropertyDescriptor$4 = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + +var NATIVE_BIND$2 = functionBindNative; + +var FunctionPrototype$3 = Function.prototype; +var call$d = FunctionPrototype$3.call; +var uncurryThisWithBind = NATIVE_BIND$2 && FunctionPrototype$3.bind.bind(call$d, call$d); + +var functionUncurryThis = NATIVE_BIND$2 ? uncurryThisWithBind : function (fn) { + return function () { + return call$d.apply(fn, arguments); + }; +}; + +var uncurryThis$k = functionUncurryThis; + +var toString$5 = uncurryThis$k({}.toString); +var stringSlice$2 = uncurryThis$k(''.slice); + +var classofRaw$2 = function (it) { + return stringSlice$2(toString$5(it), 8, -1); +}; + +var uncurryThis$j = functionUncurryThis; +var fails$g = fails$j; +var classof$9 = classofRaw$2; + +var $Object$4 = Object; +var split = uncurryThis$j(''.split); + +// fallback for non-array-like ES3 and non-enumerable old V8 strings +var indexedObject = fails$g(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object$4('z').propertyIsEnumerable(0); +}) ? function (it) { + return classof$9(it) === 'String' ? split(it, '') : $Object$4(it); +} : $Object$4; + +// we can't use just `it == null` since of `document.all` special case +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec +var isNullOrUndefined$6 = function (it) { + return it === null || it === undefined; +}; + +var isNullOrUndefined$5 = isNullOrUndefined$6; + +var $TypeError$d = TypeError; + +// `RequireObjectCoercible` abstract operation +// https://tc39.es/ecma262/#sec-requireobjectcoercible +var requireObjectCoercible$3 = function (it) { + if (isNullOrUndefined$5(it)) throw new $TypeError$d("Can't call method on " + it); + return it; +}; + +// toObject with fallback for non-array-like ES3 strings +var IndexedObject$2 = indexedObject; +var requireObjectCoercible$2 = requireObjectCoercible$3; + +var toIndexedObject$6 = function (it) { + return IndexedObject$2(requireObjectCoercible$2(it)); +}; + +var documentAll$2 = typeof document == 'object' && document.all; + +// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot +// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing +var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined; + +var documentAll_1 = { + all: documentAll$2, + IS_HTMLDDA: IS_HTMLDDA +}; + +var $documentAll$1 = documentAll_1; + +var documentAll$1 = $documentAll$1.all; + +// `IsCallable` abstract operation +// https://tc39.es/ecma262/#sec-iscallable +var isCallable$m = $documentAll$1.IS_HTMLDDA ? function (argument) { + return typeof argument == 'function' || argument === documentAll$1; +} : function (argument) { + return typeof argument == 'function'; +}; + +var isCallable$l = isCallable$m; +var $documentAll = documentAll_1; + +var documentAll = $documentAll.all; + +var isObject$f = $documentAll.IS_HTMLDDA ? function (it) { + return typeof it == 'object' ? it !== null : isCallable$l(it) || it === documentAll; +} : function (it) { + return typeof it == 'object' ? it !== null : isCallable$l(it); +}; + +var global$i = global$j; +var isCallable$k = isCallable$m; + +var aFunction = function (argument) { + return isCallable$k(argument) ? argument : undefined; +}; + +var getBuiltIn$7 = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$i[namespace]) : global$i[namespace] && global$i[namespace][method]; +}; + +var uncurryThis$i = functionUncurryThis; + +var objectIsPrototypeOf = uncurryThis$i({}.isPrototypeOf); + +var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || ''; + +var global$h = global$j; +var userAgent$3 = engineUserAgent; + +var process$3 = global$h.process; +var Deno$1 = global$h.Deno; +var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version; +var v8 = versions && versions.v8; +var match, version; + +if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); +} + +// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` +// so check `userAgent` even if `.v8` exists, but 0 +if (!version && userAgent$3) { + match = userAgent$3.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$3.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } +} + +var engineV8Version = version; + +/* eslint-disable es/no-symbol -- required for testing */ +var V8_VERSION$3 = engineV8Version; +var fails$f = fails$j; +var global$g = global$j; + +var $String$5 = global$g.String; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing +var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$f(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String$5(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$3 && V8_VERSION$3 < 41; +}); + +/* eslint-disable es/no-symbol -- required for testing */ +var NATIVE_SYMBOL$1 = symbolConstructorDetection; + +var useSymbolAsUid = NATIVE_SYMBOL$1 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + +var getBuiltIn$6 = getBuiltIn$7; +var isCallable$j = isCallable$m; +var isPrototypeOf$2 = objectIsPrototypeOf; +var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + +var $Object$3 = Object; + +var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) { + return typeof it == 'symbol'; +} : function (it) { + var $Symbol = getBuiltIn$6('Symbol'); + return isCallable$j($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it)); +}; + +var $String$4 = String; + +var tryToString$4 = function (argument) { + try { + return $String$4(argument); + } catch (error) { + return 'Object'; + } +}; + +var isCallable$i = isCallable$m; +var tryToString$3 = tryToString$4; + +var $TypeError$c = TypeError; + +// `Assert: IsCallable(argument) is true` +var aCallable$8 = function (argument) { + if (isCallable$i(argument)) return argument; + throw new $TypeError$c(tryToString$3(argument) + ' is not a function'); +}; + +var aCallable$7 = aCallable$8; +var isNullOrUndefined$4 = isNullOrUndefined$6; + +// `GetMethod` abstract operation +// https://tc39.es/ecma262/#sec-getmethod +var getMethod$3 = function (V, P) { + var func = V[P]; + return isNullOrUndefined$4(func) ? undefined : aCallable$7(func); +}; + +var call$c = functionCall; +var isCallable$h = isCallable$m; +var isObject$e = isObject$f; + +var $TypeError$b = TypeError; + +// `OrdinaryToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-ordinarytoprimitive +var ordinaryToPrimitive$1 = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable$h(fn = input.toString) && !isObject$e(val = call$c(fn, input))) return val; + if (isCallable$h(fn = input.valueOf) && !isObject$e(val = call$c(fn, input))) return val; + if (pref !== 'string' && isCallable$h(fn = input.toString) && !isObject$e(val = call$c(fn, input))) return val; + throw new $TypeError$b("Can't convert object to primitive value"); +}; + +var shared$3 = {exports: {}}; + +var global$f = global$j; + +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty$7 = Object.defineProperty; + +var defineGlobalProperty$3 = function (key, value) { + try { + defineProperty$7(global$f, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$f[key] = value; + } return value; +}; + +var global$e = global$j; +var defineGlobalProperty$2 = defineGlobalProperty$3; + +var SHARED = '__core-js_shared__'; +var store$3 = global$e[SHARED] || defineGlobalProperty$2(SHARED, {}); + +var sharedStore = store$3; + +var store$2 = sharedStore; + +(shared$3.exports = function (key, value) { + return store$2[key] || (store$2[key] = value !== undefined ? value : {}); +})('versions', []).push({ + version: '3.34.0', + mode: 'global', + copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE', + source: 'https://github.com/zloirock/core-js' +}); + +var sharedExports = shared$3.exports; + +var requireObjectCoercible$1 = requireObjectCoercible$3; + +var $Object$2 = Object; + +// `ToObject` abstract operation +// https://tc39.es/ecma262/#sec-toobject +var toObject$5 = function (argument) { + return $Object$2(requireObjectCoercible$1(argument)); +}; + +var uncurryThis$h = functionUncurryThis; +var toObject$4 = toObject$5; + +var hasOwnProperty = uncurryThis$h({}.hasOwnProperty); + +// `HasOwnProperty` abstract operation +// https://tc39.es/ecma262/#sec-hasownproperty +// eslint-disable-next-line es/no-object-hasown -- safe +var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject$4(it), key); +}; + +var uncurryThis$g = functionUncurryThis; + +var id$2 = 0; +var postfix = Math.random(); +var toString$4 = uncurryThis$g(1.0.toString); + +var uid$3 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$4(++id$2 + postfix, 36); +}; + +var global$d = global$j; +var shared$2 = sharedExports; +var hasOwn$b = hasOwnProperty_1; +var uid$2 = uid$3; +var NATIVE_SYMBOL = symbolConstructorDetection; +var USE_SYMBOL_AS_UID = useSymbolAsUid; + +var Symbol$1 = global$d.Symbol; +var WellKnownSymbolsStore = shared$2('wks'); +var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$2; + +var wellKnownSymbol$h = function (name) { + if (!hasOwn$b(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$b(Symbol$1, name) + ? Symbol$1[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; +}; + +var call$b = functionCall; +var isObject$d = isObject$f; +var isSymbol$1 = isSymbol$2; +var getMethod$2 = getMethod$3; +var ordinaryToPrimitive = ordinaryToPrimitive$1; +var wellKnownSymbol$g = wellKnownSymbol$h; + +var $TypeError$a = TypeError; +var TO_PRIMITIVE = wellKnownSymbol$g('toPrimitive'); + +// `ToPrimitive` abstract operation +// https://tc39.es/ecma262/#sec-toprimitive +var toPrimitive$1 = function (input, pref) { + if (!isObject$d(input) || isSymbol$1(input)) return input; + var exoticToPrim = getMethod$2(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$b(exoticToPrim, input, pref); + if (!isObject$d(result) || isSymbol$1(result)) return result; + throw new $TypeError$a("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); +}; + +var toPrimitive = toPrimitive$1; +var isSymbol = isSymbol$2; + +// `ToPropertyKey` abstract operation +// https://tc39.es/ecma262/#sec-topropertykey +var toPropertyKey$3 = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; +}; + +var global$c = global$j; +var isObject$c = isObject$f; + +var document$3 = global$c.document; +// typeof document.createElement is 'object' in old IE +var EXISTS$1 = isObject$c(document$3) && isObject$c(document$3.createElement); + +var documentCreateElement$2 = function (it) { + return EXISTS$1 ? document$3.createElement(it) : {}; +}; + +var DESCRIPTORS$b = descriptors; +var fails$e = fails$j; +var createElement$1 = documentCreateElement$2; + +// Thanks to IE8 for its funny defineProperty +var ie8DomDefine = !DESCRIPTORS$b && !fails$e(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { + get: function () { return 7; } + }).a !== 7; +}); + +var DESCRIPTORS$a = descriptors; +var call$a = functionCall; +var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; +var createPropertyDescriptor$3 = createPropertyDescriptor$4; +var toIndexedObject$5 = toIndexedObject$6; +var toPropertyKey$2 = toPropertyKey$3; +var hasOwn$a = hasOwnProperty_1; +var IE8_DOM_DEFINE$1 = ie8DomDefine; + +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; + +// `Object.getOwnPropertyDescriptor` method +// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor +objectGetOwnPropertyDescriptor.f = DESCRIPTORS$a ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$5(O); + P = toPropertyKey$2(P); + if (IE8_DOM_DEFINE$1) try { + return $getOwnPropertyDescriptor$1(O, P); + } catch (error) { /* empty */ } + if (hasOwn$a(O, P)) return createPropertyDescriptor$3(!call$a(propertyIsEnumerableModule$1.f, O, P), O[P]); +}; + +var objectDefineProperty = {}; + +var DESCRIPTORS$9 = descriptors; +var fails$d = fails$j; + +// V8 ~ Chrome 36- +// https://bugs.chromium.org/p/v8/issues/detail?id=3334 +var v8PrototypeDefineBug = DESCRIPTORS$9 && fails$d(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; +}); + +var isObject$b = isObject$f; + +var $String$3 = String; +var $TypeError$9 = TypeError; + +// `Assert: Type(argument) is Object` +var anObject$b = function (argument) { + if (isObject$b(argument)) return argument; + throw new $TypeError$9($String$3(argument) + ' is not an object'); +}; + +var DESCRIPTORS$8 = descriptors; +var IE8_DOM_DEFINE = ie8DomDefine; +var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug; +var anObject$a = anObject$b; +var toPropertyKey$1 = toPropertyKey$3; + +var $TypeError$8 = TypeError; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var $defineProperty = Object.defineProperty; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +var ENUMERABLE = 'enumerable'; +var CONFIGURABLE$1 = 'configurable'; +var WRITABLE = 'writable'; + +// `Object.defineProperty` method +// https://tc39.es/ecma262/#sec-object.defineproperty +objectDefineProperty.f = DESCRIPTORS$8 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) { + anObject$a(O); + P = toPropertyKey$1(P); + anObject$a(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); +} : $defineProperty : function defineProperty(O, P, Attributes) { + anObject$a(O); + P = toPropertyKey$1(P); + anObject$a(Attributes); + if (IE8_DOM_DEFINE) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$8('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + +var DESCRIPTORS$7 = descriptors; +var definePropertyModule$4 = objectDefineProperty; +var createPropertyDescriptor$2 = createPropertyDescriptor$4; + +var createNonEnumerableProperty$4 = DESCRIPTORS$7 ? function (object, key, value) { + return definePropertyModule$4.f(object, key, createPropertyDescriptor$2(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + +var makeBuiltIn$3 = {exports: {}}; + +var DESCRIPTORS$6 = descriptors; +var hasOwn$9 = hasOwnProperty_1; + +var FunctionPrototype$2 = Function.prototype; +// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe +var getDescriptor = DESCRIPTORS$6 && Object.getOwnPropertyDescriptor; + +var EXISTS = hasOwn$9(FunctionPrototype$2, 'name'); +// additional protection from minified / mangled / dropped function names +var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something'; +var CONFIGURABLE = EXISTS && (!DESCRIPTORS$6 || (DESCRIPTORS$6 && getDescriptor(FunctionPrototype$2, 'name').configurable)); + +var functionName = { + EXISTS: EXISTS, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE +}; + +var uncurryThis$f = functionUncurryThis; +var isCallable$g = isCallable$m; +var store$1 = sharedStore; + +var functionToString$1 = uncurryThis$f(Function.toString); + +// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper +if (!isCallable$g(store$1.inspectSource)) { + store$1.inspectSource = function (it) { + return functionToString$1(it); + }; +} + +var inspectSource$3 = store$1.inspectSource; + +var global$b = global$j; +var isCallable$f = isCallable$m; + +var WeakMap$1 = global$b.WeakMap; + +var weakMapBasicDetection = isCallable$f(WeakMap$1) && /native code/.test(String(WeakMap$1)); + +var shared$1 = sharedExports; +var uid$1 = uid$3; + +var keys = shared$1('keys'); + +var sharedKey$3 = function (key) { + return keys[key] || (keys[key] = uid$1(key)); +}; + +var hiddenKeys$5 = {}; + +var NATIVE_WEAK_MAP = weakMapBasicDetection; +var global$a = global$j; +var isObject$a = isObject$f; +var createNonEnumerableProperty$3 = createNonEnumerableProperty$4; +var hasOwn$8 = hasOwnProperty_1; +var shared = sharedStore; +var sharedKey$2 = sharedKey$3; +var hiddenKeys$4 = hiddenKeys$5; + +var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; +var TypeError$2 = global$a.TypeError; +var WeakMap = global$a.WeakMap; +var set$1, get, has; + +var enforce = function (it) { + return has(it) ? get(it) : set$1(it, {}); +}; + +var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject$a(it) || (state = get(it)).type !== TYPE) { + throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; +}; + +if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set$1 = function (it, metadata) { + if (store.has(it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get = function (it) { + return store.get(it) || {}; + }; + has = function (it) { + return store.has(it); + }; +} else { + var STATE = sharedKey$2('state'); + hiddenKeys$4[STATE] = true; + set$1 = function (it, metadata) { + if (hasOwn$8(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty$3(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn$8(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn$8(it, STATE); + }; +} + +var internalState = { + set: set$1, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor +}; + +var uncurryThis$e = functionUncurryThis; +var fails$c = fails$j; +var isCallable$e = isCallable$m; +var hasOwn$7 = hasOwnProperty_1; +var DESCRIPTORS$5 = descriptors; +var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE; +var inspectSource$2 = inspectSource$3; +var InternalStateModule$4 = internalState; + +var enforceInternalState = InternalStateModule$4.enforce; +var getInternalState$2 = InternalStateModule$4.get; +var $String$2 = String; +// eslint-disable-next-line es/no-object-defineproperty -- safe +var defineProperty$6 = Object.defineProperty; +var stringSlice$1 = uncurryThis$e(''.slice); +var replace = uncurryThis$e(''.replace); +var join = uncurryThis$e([].join); + +var CONFIGURABLE_LENGTH = DESCRIPTORS$5 && !fails$c(function () { + return defineProperty$6(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; +}); + +var TEMPLATE = String(String).split('String'); + +var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) { + if (stringSlice$1($String$2(name), 0, 7) === 'Symbol(') { + name = '[' + replace($String$2(name), /^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn$7(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) { + if (DESCRIPTORS$5) defineProperty$6(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn$7(options, 'arity') && value.length !== options.arity) { + defineProperty$6(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn$7(options, 'constructor') && options.constructor) { + if (DESCRIPTORS$5) defineProperty$6(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn$7(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; +}; + +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +// eslint-disable-next-line no-extend-native -- required +Function.prototype.toString = makeBuiltIn$2(function toString() { + return isCallable$e(this) && getInternalState$2(this).source || inspectSource$2(this); +}, 'toString'); + +var makeBuiltInExports = makeBuiltIn$3.exports; + +var isCallable$d = isCallable$m; +var definePropertyModule$3 = objectDefineProperty; +var makeBuiltIn$1 = makeBuiltInExports; +var defineGlobalProperty$1 = defineGlobalProperty$3; + +var defineBuiltIn$8 = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable$d(value)) makeBuiltIn$1(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty$1(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule$3.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; +}; + +var objectGetOwnPropertyNames = {}; + +var ceil = Math.ceil; +var floor = Math.floor; + +// `Math.trunc` method +// https://tc39.es/ecma262/#sec-math.trunc +// eslint-disable-next-line es/no-math-trunc -- safe +var mathTrunc = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor : ceil)(n); +}; + +var trunc = mathTrunc; + +// `ToIntegerOrInfinity` abstract operation +// https://tc39.es/ecma262/#sec-tointegerorinfinity +var toIntegerOrInfinity$3 = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); +}; + +var toIntegerOrInfinity$2 = toIntegerOrInfinity$3; + +var max$1 = Math.max; +var min$1 = Math.min; + +// Helper for a popular repeating case of the spec: +// Let integer be ? ToInteger(index). +// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). +var toAbsoluteIndex$2 = function (index, length) { + var integer = toIntegerOrInfinity$2(index); + return integer < 0 ? max$1(integer + length, 0) : min$1(integer, length); +}; + +var toIntegerOrInfinity$1 = toIntegerOrInfinity$3; + +var min = Math.min; + +// `ToLength` abstract operation +// https://tc39.es/ecma262/#sec-tolength +var toLength$1 = function (argument) { + return argument > 0 ? min(toIntegerOrInfinity$1(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 +}; + +var toLength = toLength$1; + +// `LengthOfArrayLike` abstract operation +// https://tc39.es/ecma262/#sec-lengthofarraylike +var lengthOfArrayLike$5 = function (obj) { + return toLength(obj.length); +}; + +var toIndexedObject$4 = toIndexedObject$6; +var toAbsoluteIndex$1 = toAbsoluteIndex$2; +var lengthOfArrayLike$4 = lengthOfArrayLike$5; + +// `Array.prototype.{ indexOf, includes }` methods implementation +var createMethod$2 = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject$4($this); + var length = lengthOfArrayLike$4(O); + var index = toAbsoluteIndex$1(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; +}; + +var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod$2(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod$2(false) +}; + +var uncurryThis$d = functionUncurryThis; +var hasOwn$6 = hasOwnProperty_1; +var toIndexedObject$3 = toIndexedObject$6; +var indexOf = arrayIncludes.indexOf; +var hiddenKeys$3 = hiddenKeys$5; + +var push$1 = uncurryThis$d([].push); + +var objectKeysInternal = function (object, names) { + var O = toIndexedObject$3(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn$6(hiddenKeys$3, key) && hasOwn$6(O, key) && push$1(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn$6(O, key = names[i++])) { + ~indexOf(result, key) || push$1(result, key); + } + return result; +}; + +// IE8- don't enum bug keys +var enumBugKeys$3 = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' +]; + +var internalObjectKeys$1 = objectKeysInternal; +var enumBugKeys$2 = enumBugKeys$3; + +var hiddenKeys$2 = enumBugKeys$2.concat('length', 'prototype'); + +// `Object.getOwnPropertyNames` method +// https://tc39.es/ecma262/#sec-object.getownpropertynames +// eslint-disable-next-line es/no-object-getownpropertynames -- safe +objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys$2); +}; + +var objectGetOwnPropertySymbols = {}; + +// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe +objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; + +var getBuiltIn$5 = getBuiltIn$7; +var uncurryThis$c = functionUncurryThis; +var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames; +var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; +var anObject$9 = anObject$b; + +var concat$1 = uncurryThis$c([].concat); + +// all object keys, includes non-enumerable and symbols +var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule$1.f(anObject$9(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f; + return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys; +}; + +var hasOwn$5 = hasOwnProperty_1; +var ownKeys = ownKeys$1; +var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; +var definePropertyModule$2 = objectDefineProperty; + +var copyConstructorProperties$1 = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule$2.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn$5(target, key) && !(exceptions && hasOwn$5(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } +}; + +var fails$b = fails$j; +var isCallable$c = isCallable$m; + +var replacement = /#|\.prototype\./; + +var isForced$3 = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable$c(detection) ? fails$b(detection) + : !!detection; +}; + +var normalize = isForced$3.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); +}; + +var data = isForced$3.data = {}; +var NATIVE = isForced$3.NATIVE = 'N'; +var POLYFILL = isForced$3.POLYFILL = 'P'; + +var isForced_1 = isForced$3; + +var global$9 = global$j; +var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; +var createNonEnumerableProperty$2 = createNonEnumerableProperty$4; +var defineBuiltIn$7 = defineBuiltIn$8; +var defineGlobalProperty = defineGlobalProperty$3; +var copyConstructorProperties = copyConstructorProperties$1; +var isForced$2 = isForced_1; + +/* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key +*/ +var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global$9; + } else if (STATIC) { + target = global$9[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = (global$9[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor$1(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced$2(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty$2(sourceProperty, 'sham', true); + } + defineBuiltIn$7(target, key, sourceProperty, options); + } +}; + +var classof$8 = classofRaw$2; + +// `IsArray` abstract operation +// https://tc39.es/ecma262/#sec-isarray +// eslint-disable-next-line es/no-array-isarray -- safe +var isArray$2 = Array.isArray || function isArray(argument) { + return classof$8(argument) === 'Array'; +}; + +var $TypeError$7 = TypeError; +var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991 + +var doesNotExceedSafeInteger$1 = function (it) { + if (it > MAX_SAFE_INTEGER) throw $TypeError$7('Maximum allowed index exceeded'); + return it; +}; + +var toPropertyKey = toPropertyKey$3; +var definePropertyModule$1 = objectDefineProperty; +var createPropertyDescriptor$1 = createPropertyDescriptor$4; + +var createProperty$2 = function (object, key, value) { + var propertyKey = toPropertyKey(key); + if (propertyKey in object) definePropertyModule$1.f(object, propertyKey, createPropertyDescriptor$1(0, value)); + else object[propertyKey] = value; +}; + +var wellKnownSymbol$f = wellKnownSymbol$h; + +var TO_STRING_TAG$2 = wellKnownSymbol$f('toStringTag'); +var test = {}; + +test[TO_STRING_TAG$2] = 'z'; + +var toStringTagSupport = String(test) === '[object z]'; + +var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; +var isCallable$b = isCallable$m; +var classofRaw$1 = classofRaw$2; +var wellKnownSymbol$e = wellKnownSymbol$h; + +var TO_STRING_TAG$1 = wellKnownSymbol$e('toStringTag'); +var $Object$1 = Object; + +// ES3 wrong here +var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments'; + +// fallback for IE11 Script Access Denied error +var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } +}; + +// getting tag from ES6+ `Object.prototype.toString` +var classof$7 = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object$1(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw$1(O) + // ES3 arguments fallback + : (result = classofRaw$1(O)) === 'Object' && isCallable$b(O.callee) ? 'Arguments' : result; +}; + +var uncurryThis$b = functionUncurryThis; +var fails$a = fails$j; +var isCallable$a = isCallable$m; +var classof$6 = classof$7; +var getBuiltIn$4 = getBuiltIn$7; +var inspectSource$1 = inspectSource$3; + +var noop = function () { /* empty */ }; +var empty = []; +var construct = getBuiltIn$4('Reflect', 'construct'); +var constructorRegExp = /^\s*(?:class|function)\b/; +var exec = uncurryThis$b(constructorRegExp.exec); +var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + +var isConstructorModern = function isConstructor(argument) { + if (!isCallable$a(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } +}; + +var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$a(argument)) return false; + switch (classof$6(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } +}; + +isConstructorLegacy.sham = true; + +// `IsConstructor` abstract operation +// https://tc39.es/ecma262/#sec-isconstructor +var isConstructor$2 = !construct || fails$a(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; +}) ? isConstructorLegacy : isConstructorModern; + +var isArray$1 = isArray$2; +var isConstructor$1 = isConstructor$2; +var isObject$9 = isObject$f; +var wellKnownSymbol$d = wellKnownSymbol$h; + +var SPECIES$4 = wellKnownSymbol$d('species'); +var $Array$1 = Array; + +// a part of `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +var arraySpeciesConstructor$1 = function (originalArray) { + var C; + if (isArray$1(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor$1(C) && (C === $Array$1 || isArray$1(C.prototype))) C = undefined; + else if (isObject$9(C)) { + C = C[SPECIES$4]; + if (C === null) C = undefined; + } + } return C === undefined ? $Array$1 : C; +}; + +var arraySpeciesConstructor = arraySpeciesConstructor$1; + +// `ArraySpeciesCreate` abstract operation +// https://tc39.es/ecma262/#sec-arrayspeciescreate +var arraySpeciesCreate$2 = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); +}; + +var fails$9 = fails$j; +var wellKnownSymbol$c = wellKnownSymbol$h; +var V8_VERSION$2 = engineV8Version; + +var SPECIES$3 = wellKnownSymbol$c('species'); + +var arrayMethodHasSpeciesSupport$1 = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return V8_VERSION$2 >= 51 || !fails$9(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES$3] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); +}; + +var $$a = _export; +var fails$8 = fails$j; +var isArray = isArray$2; +var isObject$8 = isObject$f; +var toObject$3 = toObject$5; +var lengthOfArrayLike$3 = lengthOfArrayLike$5; +var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1; +var createProperty$1 = createProperty$2; +var arraySpeciesCreate$1 = arraySpeciesCreate$2; +var arrayMethodHasSpeciesSupport = arrayMethodHasSpeciesSupport$1; +var wellKnownSymbol$b = wellKnownSymbol$h; +var V8_VERSION$1 = engineV8Version; + +var IS_CONCAT_SPREADABLE = wellKnownSymbol$b('isConcatSpreadable'); + +// We can't use this feature detection in V8 since it causes +// deoptimization and serious performance degradation +// https://github.com/zloirock/core-js/issues/679 +var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION$1 >= 51 || !fails$8(function () { + var array = []; + array[IS_CONCAT_SPREADABLE] = false; + return array.concat()[0] !== array; +}); + +var isConcatSpreadable = function (O) { + if (!isObject$8(O)) return false; + var spreadable = O[IS_CONCAT_SPREADABLE]; + return spreadable !== undefined ? !!spreadable : isArray(O); +}; + +var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat'); + +// `Array.prototype.concat` method +// https://tc39.es/ecma262/#sec-array.prototype.concat +// with adding support of @@isConcatSpreadable and @@species +$$a({ target: 'Array', proto: true, arity: 1, forced: FORCED }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + concat: function concat(arg) { + var O = toObject$3(this); + var A = arraySpeciesCreate$1(O, 0); + var n = 0; + var i, k, length, len, E; + for (i = -1, length = arguments.length; i < length; i++) { + E = i === -1 ? O : arguments[i]; + if (isConcatSpreadable(E)) { + len = lengthOfArrayLike$3(E); + doesNotExceedSafeInteger(n + len); + for (k = 0; k < len; k++, n++) if (k in E) createProperty$1(A, n, E[k]); + } else { + doesNotExceedSafeInteger(n + 1); + createProperty$1(A, n++, E); + } + } + A.length = n; + return A; + } +}); + +var makeBuiltIn = makeBuiltInExports; +var defineProperty$5 = objectDefineProperty; + +var defineBuiltInAccessor$2 = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true }); + return defineProperty$5.f(target, name, descriptor); +}; + +var DESCRIPTORS$4 = descriptors; +var FUNCTION_NAME_EXISTS = functionName.EXISTS; +var uncurryThis$a = functionUncurryThis; +var defineBuiltInAccessor$1 = defineBuiltInAccessor$2; + +var FunctionPrototype$1 = Function.prototype; +var functionToString = uncurryThis$a(FunctionPrototype$1.toString); +var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; +var regExpExec = uncurryThis$a(nameRE.exec); +var NAME = 'name'; + +// Function instances `.name` property +// https://tc39.es/ecma262/#sec-function-instances-name +if (DESCRIPTORS$4 && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor$1(FunctionPrototype$1, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); +} + +var internalObjectKeys = objectKeysInternal; +var enumBugKeys$1 = enumBugKeys$3; + +// `Object.keys` method +// https://tc39.es/ecma262/#sec-object.keys +// eslint-disable-next-line es/no-object-keys -- safe +var objectKeys$2 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys$1); +}; + +var DESCRIPTORS$3 = descriptors; +var uncurryThis$9 = functionUncurryThis; +var call$9 = functionCall; +var fails$7 = fails$j; +var objectKeys$1 = objectKeys$2; +var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; +var propertyIsEnumerableModule = objectPropertyIsEnumerable; +var toObject$2 = toObject$5; +var IndexedObject$1 = indexedObject; + +// eslint-disable-next-line es/no-object-assign -- safe +var $assign = Object.assign; +// eslint-disable-next-line es/no-object-defineproperty -- required for testing +var defineProperty$4 = Object.defineProperty; +var concat = uncurryThis$9([].concat); + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +var objectAssign = !$assign || fails$7(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$3 && $assign({ b: 1 }, $assign(defineProperty$4({}, 'a', { + enumerable: true, + get: function () { + defineProperty$4(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys$1($assign({}, B)).join('') !== alphabet; +}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject$2(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject$1(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$3 || call$9(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; +} : $assign; + +var $$9 = _export; +var assign = objectAssign; + +// `Object.assign` method +// https://tc39.es/ecma262/#sec-object.assign +// eslint-disable-next-line es/no-object-assign -- required for testing +$$9({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign +}); + +var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; +var classof$5 = classof$7; + +// `Object.prototype.toString` method implementation +// https://tc39.es/ecma262/#sec-object.prototype.tostring +var objectToString = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$5(this) + ']'; +}; + +var TO_STRING_TAG_SUPPORT = toStringTagSupport; +var defineBuiltIn$6 = defineBuiltIn$8; +var toString$3 = objectToString; + +// `Object.prototype.toString` method +// https://tc39.es/ecma262/#sec-object.prototype.tostring +if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn$6(Object.prototype, 'toString', toString$3, { unsafe: true }); +} + +var global$8 = global$j; +var classof$4 = classofRaw$2; + +var engineIsNode = classof$4(global$8.process) === 'process'; + +var uncurryThis$8 = functionUncurryThis; +var aCallable$6 = aCallable$8; + +var functionUncurryThisAccessor = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis$8(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } +}; + +var isCallable$9 = isCallable$m; + +var $String$1 = String; +var $TypeError$6 = TypeError; + +var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$9(argument)) return argument; + throw new $TypeError$6("Can't set " + $String$1(argument) + ' as a prototype'); +}; + +/* eslint-disable no-proto -- safe */ +var uncurryThisAccessor = functionUncurryThisAccessor; +var anObject$8 = anObject$b; +var aPossiblePrototype = aPossiblePrototype$1; + +// `Object.setPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.setprototypeof +// Works with __proto__ only. Old v8 can't work with null proto objects. +// eslint-disable-next-line es/no-object-setprototypeof -- safe +var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject$8(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; +}() : undefined); + +var defineProperty$3 = objectDefineProperty.f; +var hasOwn$4 = hasOwnProperty_1; +var wellKnownSymbol$a = wellKnownSymbol$h; + +var TO_STRING_TAG = wellKnownSymbol$a('toStringTag'); + +var setToStringTag$5 = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$4(target, TO_STRING_TAG)) { + defineProperty$3(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } +}; + +var getBuiltIn$3 = getBuiltIn$7; +var defineBuiltInAccessor = defineBuiltInAccessor$2; +var wellKnownSymbol$9 = wellKnownSymbol$h; +var DESCRIPTORS$2 = descriptors; + +var SPECIES$2 = wellKnownSymbol$9('species'); + +var setSpecies$1 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME); + + if (DESCRIPTORS$2 && Constructor && !Constructor[SPECIES$2]) { + defineBuiltInAccessor(Constructor, SPECIES$2, { + configurable: true, + get: function () { return this; } + }); + } +}; + +var isPrototypeOf$1 = objectIsPrototypeOf; + +var $TypeError$5 = TypeError; + +var anInstance$3 = function (it, Prototype) { + if (isPrototypeOf$1(Prototype, it)) return it; + throw new $TypeError$5('Incorrect invocation'); +}; + +var isConstructor = isConstructor$2; +var tryToString$2 = tryToString$4; + +var $TypeError$4 = TypeError; + +// `Assert: IsConstructor(argument) is true` +var aConstructor$1 = function (argument) { + if (isConstructor(argument)) return argument; + throw new $TypeError$4(tryToString$2(argument) + ' is not a constructor'); +}; + +var anObject$7 = anObject$b; +var aConstructor = aConstructor$1; +var isNullOrUndefined$3 = isNullOrUndefined$6; +var wellKnownSymbol$8 = wellKnownSymbol$h; + +var SPECIES$1 = wellKnownSymbol$8('species'); + +// `SpeciesConstructor` abstract operation +// https://tc39.es/ecma262/#sec-speciesconstructor +var speciesConstructor$1 = function (O, defaultConstructor) { + var C = anObject$7(O).constructor; + var S; + return C === undefined || isNullOrUndefined$3(S = anObject$7(C)[SPECIES$1]) ? defaultConstructor : aConstructor(S); +}; + +var NATIVE_BIND$1 = functionBindNative; + +var FunctionPrototype = Function.prototype; +var apply$1 = FunctionPrototype.apply; +var call$8 = FunctionPrototype.call; + +// eslint-disable-next-line es/no-reflect -- safe +var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$8.bind(apply$1) : function () { + return call$8.apply(apply$1, arguments); +}); + +var classofRaw = classofRaw$2; +var uncurryThis$7 = functionUncurryThis; + +var functionUncurryThisClause = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis$7(fn); +}; + +var uncurryThis$6 = functionUncurryThisClause; +var aCallable$5 = aCallable$8; +var NATIVE_BIND = functionBindNative; + +var bind$5 = uncurryThis$6(uncurryThis$6.bind); + +// optional / simple context binding +var functionBindContext = function (fn, that) { + aCallable$5(fn); + return that === undefined ? fn : NATIVE_BIND ? bind$5(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; +}; + +var getBuiltIn$2 = getBuiltIn$7; + +var html$2 = getBuiltIn$2('document', 'documentElement'); + +var uncurryThis$5 = functionUncurryThis; + +var arraySlice$2 = uncurryThis$5([].slice); + +var $TypeError$3 = TypeError; + +var validateArgumentsLength$1 = function (passed, required) { + if (passed < required) throw new $TypeError$3('Not enough arguments'); + return passed; +}; + +var userAgent$2 = engineUserAgent; + +// eslint-disable-next-line redos/no-vulnerable -- safe +var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2); + +var global$7 = global$j; +var apply = functionApply; +var bind$4 = functionBindContext; +var isCallable$8 = isCallable$m; +var hasOwn$3 = hasOwnProperty_1; +var fails$6 = fails$j; +var html$1 = html$2; +var arraySlice$1 = arraySlice$2; +var createElement = documentCreateElement$2; +var validateArgumentsLength = validateArgumentsLength$1; +var IS_IOS$1 = engineIsIos; +var IS_NODE$3 = engineIsNode; + +var set = global$7.setImmediate; +var clear = global$7.clearImmediate; +var process$2 = global$7.process; +var Dispatch = global$7.Dispatch; +var Function$1 = global$7.Function; +var MessageChannel = global$7.MessageChannel; +var String$1 = global$7.String; +var counter = 0; +var queue$2 = {}; +var ONREADYSTATECHANGE = 'onreadystatechange'; +var $location, defer, channel, port; + +fails$6(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = global$7.location; +}); + +var run = function (id) { + if (hasOwn$3(queue$2, id)) { + var fn = queue$2[id]; + delete queue$2[id]; + fn(); + } +}; + +var runner = function (id) { + return function () { + run(id); + }; +}; + +var eventListener = function (event) { + run(event.data); +}; + +var globalPostMessageDefer = function (id) { + // old engines have not location.origin + global$7.postMessage(String$1(id), $location.protocol + '//' + $location.host); +}; + +// Node.js 0.9+ & IE10+ has setImmediate, otherwise: +if (!set || !clear) { + set = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable$8(handler) ? handler : Function$1(handler); + var args = arraySlice$1(arguments, 1); + queue$2[++counter] = function () { + apply(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue$2[id]; + }; + // Node.js 0.8- + if (IS_NODE$3) { + defer = function (id) { + process$2.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS$1) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind$4(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global$7.addEventListener && + isCallable$8(global$7.postMessage) && + !global$7.importScripts && + $location && $location.protocol !== 'file:' && + !fails$6(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + global$7.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html$1.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } +} + +var task$1 = { + set: set, + clear: clear +}; + +var Queue$2 = function () { + this.head = null; + this.tail = null; +}; + +Queue$2.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } +}; + +var queue$1 = Queue$2; + +var userAgent$1 = engineUserAgent; + +var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && typeof Pebble != 'undefined'; + +var userAgent = engineUserAgent; + +var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent); + +var global$6 = global$j; +var bind$3 = functionBindContext; +var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; +var macrotask = task$1.set; +var Queue$1 = queue$1; +var IS_IOS = engineIsIos; +var IS_IOS_PEBBLE = engineIsIosPebble; +var IS_WEBOS_WEBKIT = engineIsWebosWebkit; +var IS_NODE$2 = engineIsNode; + +var MutationObserver = global$6.MutationObserver || global$6.WebKitMutationObserver; +var document$2 = global$6.document; +var process$1 = global$6.process; +var Promise$1 = global$6.Promise; +// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` +var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$6, 'queueMicrotask'); +var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; +var notify$1, toggle, node, promise, then; + +// modern engines have queueMicrotask method +if (!microtask$1) { + var queue = new Queue$1(); + + var flush = function () { + var parent, fn; + if (IS_NODE$2 && (parent = process$1.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify$1(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { + toggle = true; + node = document$2.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify$1 = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise$1.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise$1; + then = bind$3(promise.then, promise); + notify$1 = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE$2) { + notify$1 = function () { + process$1.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind$3(macrotask, global$6); + notify$1 = function () { + macrotask(flush); + }; + } + + microtask$1 = function (fn) { + if (!queue.head) notify$1(); + queue.add(fn); + }; +} + +var microtask_1 = microtask$1; + +var hostReportErrors$1 = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } +}; + +var perform$3 = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } +}; + +var global$5 = global$j; + +var promiseNativeConstructor = global$5.Promise; + +/* global Deno -- Deno case */ +var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object'; + +var IS_DENO$1 = engineIsDeno; +var IS_NODE$1 = engineIsNode; + +var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 + && typeof window == 'object' + && typeof document == 'object'; + +var global$4 = global$j; +var NativePromiseConstructor$3 = promiseNativeConstructor; +var isCallable$7 = isCallable$m; +var isForced$1 = isForced_1; +var inspectSource = inspectSource$3; +var wellKnownSymbol$7 = wellKnownSymbol$h; +var IS_BROWSER = engineIsBrowser; +var IS_DENO = engineIsDeno; +var V8_VERSION = engineV8Version; + +NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype; +var SPECIES = wellKnownSymbol$7('species'); +var SUBCLASSING = false; +var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$7(global$4.PromiseRejectionEvent); + +var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1; +}); + +var promiseConstructorDetection = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1, + SUBCLASSING: SUBCLASSING +}; + +var newPromiseCapability$2 = {}; + +var aCallable$4 = aCallable$8; + +var $TypeError$2 = TypeError; + +var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError$2('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable$4(resolve); + this.reject = aCallable$4(reject); +}; + +// `NewPromiseCapability` abstract operation +// https://tc39.es/ecma262/#sec-newpromisecapability +newPromiseCapability$2.f = function (C) { + return new PromiseCapability(C); +}; + +var $$8 = _export; +var IS_NODE = engineIsNode; +var global$3 = global$j; +var call$7 = functionCall; +var defineBuiltIn$5 = defineBuiltIn$8; +var setPrototypeOf$2 = objectSetPrototypeOf; +var setToStringTag$4 = setToStringTag$5; +var setSpecies = setSpecies$1; +var aCallable$3 = aCallable$8; +var isCallable$6 = isCallable$m; +var isObject$7 = isObject$f; +var anInstance$2 = anInstance$3; +var speciesConstructor = speciesConstructor$1; +var task = task$1.set; +var microtask = microtask_1; +var hostReportErrors = hostReportErrors$1; +var perform$2 = perform$3; +var Queue = queue$1; +var InternalStateModule$3 = internalState; +var NativePromiseConstructor$2 = promiseNativeConstructor; +var PromiseConstructorDetection = promiseConstructorDetection; +var newPromiseCapabilityModule$3 = newPromiseCapability$2; + +var PROMISE = 'Promise'; +var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR; +var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; +var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; +var getInternalPromiseState = InternalStateModule$3.getterFor(PROMISE); +var setInternalState$3 = InternalStateModule$3.set; +var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype; +var PromiseConstructor = NativePromiseConstructor$2; +var PromisePrototype = NativePromisePrototype$1; +var TypeError$1 = global$3.TypeError; +var document$1 = global$3.document; +var process = global$3.process; +var newPromiseCapability$1 = newPromiseCapabilityModule$3.f; +var newGenericPromiseCapability = newPromiseCapability$1; + +var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$3.dispatchEvent); +var UNHANDLED_REJECTION = 'unhandledrejection'; +var REJECTION_HANDLED = 'rejectionhandled'; +var PENDING = 0; +var FULFILLED = 1; +var REJECTED = 2; +var HANDLED = 1; +var UNHANDLED = 2; + +var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + +// helpers +var isThenable = function (it) { + var then; + return isObject$7(it) && isCallable$6(then = it.then) ? then : false; +}; + +var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$7(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } +}; + +var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); +}; + +var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$1.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global$3.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$3['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); +}; + +var onUnhandled = function (state) { + call$7(task, global$3, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform$2(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); +}; + +var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; +}; + +var onHandleUnhandled = function (state) { + call$7(task, global$3, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); +}; + +var bind$2 = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; +}; + +var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); +}; + +var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call$7(then, value, + bind$2(internalResolve, wrapper, state), + bind$2(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } +}; + +// constructor polyfill +if (FORCED_PROMISE_CONSTRUCTOR$4) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance$2(this, PromisePrototype); + aCallable$3(executor); + call$7(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind$2(internalResolve, state), bind$2(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState$3(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: undefined + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn$5(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable$6(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$6(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind$2(internalResolve, state); + this.reject = bind$2(internalReject, state); + }; + + newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (isCallable$6(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) { + nativeThen = NativePromisePrototype$1.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn$5(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call$7(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype$1.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf$2) { + setPrototypeOf$2(NativePromisePrototype$1, PromisePrototype); + } + } +} + +$$8({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, { + Promise: PromiseConstructor +}); + +setToStringTag$4(PromiseConstructor, PROMISE, false); +setSpecies(PROMISE); + +var iterators = {}; + +var wellKnownSymbol$6 = wellKnownSymbol$h; +var Iterators$4 = iterators; + +var ITERATOR$5 = wellKnownSymbol$6('iterator'); +var ArrayPrototype$1 = Array.prototype; + +// check on default Array iterator +var isArrayIteratorMethod$1 = function (it) { + return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$5] === it); +}; + +var classof$3 = classof$7; +var getMethod$1 = getMethod$3; +var isNullOrUndefined$2 = isNullOrUndefined$6; +var Iterators$3 = iterators; +var wellKnownSymbol$5 = wellKnownSymbol$h; + +var ITERATOR$4 = wellKnownSymbol$5('iterator'); + +var getIteratorMethod$2 = function (it) { + if (!isNullOrUndefined$2(it)) return getMethod$1(it, ITERATOR$4) + || getMethod$1(it, '@@iterator') + || Iterators$3[classof$3(it)]; +}; + +var call$6 = functionCall; +var aCallable$2 = aCallable$8; +var anObject$6 = anObject$b; +var tryToString$1 = tryToString$4; +var getIteratorMethod$1 = getIteratorMethod$2; + +var $TypeError$1 = TypeError; + +var getIterator$1 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator; + if (aCallable$2(iteratorMethod)) return anObject$6(call$6(iteratorMethod, argument)); + throw new $TypeError$1(tryToString$1(argument) + ' is not iterable'); +}; + +var call$5 = functionCall; +var anObject$5 = anObject$b; +var getMethod = getMethod$3; + +var iteratorClose$1 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$5(iterator); + try { + innerResult = getMethod(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$5(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$5(innerResult); + return value; +}; + +var bind$1 = functionBindContext; +var call$4 = functionCall; +var anObject$4 = anObject$b; +var tryToString = tryToString$4; +var isArrayIteratorMethod = isArrayIteratorMethod$1; +var lengthOfArrayLike$2 = lengthOfArrayLike$5; +var isPrototypeOf = objectIsPrototypeOf; +var getIterator = getIterator$1; +var getIteratorMethod = getIteratorMethod$2; +var iteratorClose = iteratorClose$1; + +var $TypeError = TypeError; + +var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; +}; + +var ResultPrototype = Result.prototype; + +var iterate$4 = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind$1(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject$4(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = lengthOfArrayLike$2(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call$4(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); +}; + +var wellKnownSymbol$4 = wellKnownSymbol$h; + +var ITERATOR$3 = wellKnownSymbol$4('iterator'); +var SAFE_CLOSING = false; + +try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR$3] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); +} catch (error) { /* empty */ } + +var checkCorrectnessOfIteration$2 = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR$3] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; +}; + +var NativePromiseConstructor$1 = promiseNativeConstructor; +var checkCorrectnessOfIteration$1 = checkCorrectnessOfIteration$2; +var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR; + +var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration$1(function (iterable) { + NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ }); +}); + +var $$7 = _export; +var call$3 = functionCall; +var aCallable$1 = aCallable$8; +var newPromiseCapabilityModule$2 = newPromiseCapability$2; +var perform$1 = perform$3; +var iterate$3 = iterate$4; +var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration; + +// `Promise.all` method +// https://tc39.es/ecma262/#sec-promise.all +$$7({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$2.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform$1(function () { + var $promiseResolve = aCallable$1(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$3(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$3($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var $$6 = _export; +var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR; +var NativePromiseConstructor = promiseNativeConstructor; +var getBuiltIn$1 = getBuiltIn$7; +var isCallable$5 = isCallable$m; +var defineBuiltIn$4 = defineBuiltIn$8; + +var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + +// `Promise.prototype.catch` method +// https://tc39.es/ecma262/#sec-promise.prototype.catch +$$6({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } +}); + +// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` +if (isCallable$5(NativePromiseConstructor)) { + var method = getBuiltIn$1('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn$4(NativePromisePrototype, 'catch', method, { unsafe: true }); + } +} + +var $$5 = _export; +var call$2 = functionCall; +var aCallable = aCallable$8; +var newPromiseCapabilityModule$1 = newPromiseCapability$2; +var perform = perform$3; +var iterate$2 = iterate$4; +var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration; + +// `Promise.race` method +// https://tc39.es/ecma262/#sec-promise.race +$$5({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$1.f(C); + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aCallable(C.resolve); + iterate$2(iterable, function (promise) { + call$2($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } +}); + +var $$4 = _export; +var call$1 = functionCall; +var newPromiseCapabilityModule = newPromiseCapability$2; +var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR; + +// `Promise.reject` method +// https://tc39.es/ecma262/#sec-promise.reject +$$4({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule.f(this); + call$1(capability.reject, undefined, r); + return capability.promise; + } +}); + +var anObject$3 = anObject$b; +var isObject$6 = isObject$f; +var newPromiseCapability = newPromiseCapability$2; + +var promiseResolve$1 = function (C, x) { + anObject$3(C); + if (isObject$6(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; +}; + +var $$3 = _export; +var getBuiltIn = getBuiltIn$7; +var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR; +var promiseResolve = promiseResolve$1; + +getBuiltIn('Promise'); + +// `Promise.resolve` method +// https://tc39.es/ecma262/#sec-promise.resolve +$$3({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(this, x); + } +}); + +var objectDefineProperties = {}; + +var DESCRIPTORS$1 = descriptors; +var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; +var definePropertyModule = objectDefineProperty; +var anObject$2 = anObject$b; +var toIndexedObject$2 = toIndexedObject$6; +var objectKeys = objectKeys$2; + +// `Object.defineProperties` method +// https://tc39.es/ecma262/#sec-object.defineproperties +// eslint-disable-next-line es/no-object-defineproperties -- safe +objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject$2(O); + var props = toIndexedObject$2(Properties); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]); + return O; +}; + +/* global ActiveXObject -- old IE, WSH */ +var anObject$1 = anObject$b; +var definePropertiesModule = objectDefineProperties; +var enumBugKeys = enumBugKeys$3; +var hiddenKeys$1 = hiddenKeys$5; +var html = html$2; +var documentCreateElement$1 = documentCreateElement$2; +var sharedKey$1 = sharedKey$3; + +var GT = '>'; +var LT = '<'; +var PROTOTYPE = 'prototype'; +var SCRIPT = 'script'; +var IE_PROTO$1 = sharedKey$1('IE_PROTO'); + +var EmptyConstructor = function () { /* empty */ }; + +var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; +}; + +// Create object with fake `null` prototype: use ActiveX Object with cleared prototype +var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; +}; + +// Create object with fake `null` prototype: use iframe Object with cleared prototype +var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement$1('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; +}; + +// Check for document.domain and active x support +// No need to use active x approach when document.domain is not set +// see https://github.com/es-shims/es5-shim/issues/150 +// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 +// avoid IE GC bug +var activeXDocument; +var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); +}; + +hiddenKeys$1[IE_PROTO$1] = true; + +// `Object.create` method +// https://tc39.es/ecma262/#sec-object.create +// eslint-disable-next-line es/no-object-create -- safe +var objectCreate = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject$1(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO$1] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : definePropertiesModule.f(result, Properties); +}; + +var wellKnownSymbol$3 = wellKnownSymbol$h; +var create$1 = objectCreate; +var defineProperty$2 = objectDefineProperty.f; + +var UNSCOPABLES = wellKnownSymbol$3('unscopables'); +var ArrayPrototype = Array.prototype; + +// Array.prototype[@@unscopables] +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +if (ArrayPrototype[UNSCOPABLES] === undefined) { + defineProperty$2(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create$1(null) + }); +} + +// add a key to Array.prototype[@@unscopables] +var addToUnscopables$1 = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; +}; + +var fails$5 = fails$j; + +var correctPrototypeGetter = !fails$5(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; +}); + +var hasOwn$2 = hasOwnProperty_1; +var isCallable$4 = isCallable$m; +var toObject$1 = toObject$5; +var sharedKey = sharedKey$3; +var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter; + +var IE_PROTO = sharedKey('IE_PROTO'); +var $Object = Object; +var ObjectPrototype = $Object.prototype; + +// `Object.getPrototypeOf` method +// https://tc39.es/ecma262/#sec-object.getprototypeof +// eslint-disable-next-line es/no-object-getprototypeof -- safe +var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) { + var object = toObject$1(O); + if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable$4(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof $Object ? ObjectPrototype : null; +}; + +var fails$4 = fails$j; +var isCallable$3 = isCallable$m; +var isObject$5 = isObject$f; +var getPrototypeOf$1 = objectGetPrototypeOf; +var defineBuiltIn$3 = defineBuiltIn$8; +var wellKnownSymbol$2 = wellKnownSymbol$h; + +var ITERATOR$2 = wellKnownSymbol$2('iterator'); +var BUGGY_SAFARI_ITERATORS$1 = false; + +// `%IteratorPrototype%` object +// https://tc39.es/ecma262/#sec-%iteratorprototype%-object +var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator; + +/* eslint-disable es/no-array-prototype-keys -- safe */ +if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype; + } +} + +var NEW_ITERATOR_PROTOTYPE = !isObject$5(IteratorPrototype$2) || fails$4(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype$2[ITERATOR$2].call(test) !== test; +}); + +if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {}; + +// `%IteratorPrototype%[@@iterator]()` method +// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator +if (!isCallable$3(IteratorPrototype$2[ITERATOR$2])) { + defineBuiltIn$3(IteratorPrototype$2, ITERATOR$2, function () { + return this; + }); +} + +var iteratorsCore = { + IteratorPrototype: IteratorPrototype$2, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1 +}; + +var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; +var create = objectCreate; +var createPropertyDescriptor = createPropertyDescriptor$4; +var setToStringTag$3 = setToStringTag$5; +var Iterators$2 = iterators; + +var returnThis$1 = function () { return this; }; + +var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) }); + setToStringTag$3(IteratorConstructor, TO_STRING_TAG, false); + Iterators$2[TO_STRING_TAG] = returnThis$1; + return IteratorConstructor; +}; + +var $$2 = _export; +var call = functionCall; +var FunctionName = functionName; +var isCallable$2 = isCallable$m; +var createIteratorConstructor = iteratorCreateConstructor; +var getPrototypeOf = objectGetPrototypeOf; +var setPrototypeOf$1 = objectSetPrototypeOf; +var setToStringTag$2 = setToStringTag$5; +var createNonEnumerableProperty$1 = createNonEnumerableProperty$4; +var defineBuiltIn$2 = defineBuiltIn$8; +var wellKnownSymbol$1 = wellKnownSymbol$h; +var Iterators$1 = iterators; +var IteratorsCore = iteratorsCore; + +var PROPER_FUNCTION_NAME = FunctionName.PROPER; +var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; +var IteratorPrototype = IteratorsCore.IteratorPrototype; +var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; +var ITERATOR$1 = wellKnownSymbol$1('iterator'); +var KEYS = 'keys'; +var VALUES = 'values'; +var ENTRIES = 'entries'; + +var returnThis = function () { return this; }; + +var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND]; + + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } + + return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR$1] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf$1) { + setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$1])) { + defineBuiltIn$2(CurrentIteratorPrototype, ITERATOR$1, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag$2(CurrentIteratorPrototype, TO_STRING_TAG, true); + } + } + + // fix Array.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty$1(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call(nativeIterator, this); }; + } + } + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + defineBuiltIn$2(IterablePrototype, KEY, methods[KEY]); + } + } else $$2({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if (IterablePrototype[ITERATOR$1] !== defaultIterator) { + defineBuiltIn$2(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT }); + } + Iterators$1[NAME] = defaultIterator; + + return methods; +}; + +// `CreateIterResultObject` abstract operation +// https://tc39.es/ecma262/#sec-createiterresultobject +var createIterResultObject$2 = function (value, done) { + return { value: value, done: done }; +}; + +var toIndexedObject$1 = toIndexedObject$6; +var addToUnscopables = addToUnscopables$1; +var Iterators = iterators; +var InternalStateModule$2 = internalState; +var defineProperty$1 = objectDefineProperty.f; +var defineIterator$1 = iteratorDefine; +var createIterResultObject$1 = createIterResultObject$2; +var DESCRIPTORS = descriptors; + +var ARRAY_ITERATOR = 'Array Iterator'; +var setInternalState$2 = InternalStateModule$2.set; +var getInternalState$1 = InternalStateModule$2.getterFor(ARRAY_ITERATOR); + +// `Array.prototype.entries` method +// https://tc39.es/ecma262/#sec-array.prototype.entries +// `Array.prototype.keys` method +// https://tc39.es/ecma262/#sec-array.prototype.keys +// `Array.prototype.values` method +// https://tc39.es/ecma262/#sec-array.prototype.values +// `Array.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-array.prototype-@@iterator +// `CreateArrayIterator` internal method +// https://tc39.es/ecma262/#sec-createarrayiterator +var es_array_iterator = defineIterator$1(Array, 'Array', function (iterated, kind) { + setInternalState$2(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject$1(iterated), // target + index: 0, // next index + kind: kind // kind + }); +// `%ArrayIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next +}, function () { + var state = getInternalState$1(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return createIterResultObject$1(undefined, true); + } + switch (state.kind) { + case 'keys': return createIterResultObject$1(index, false); + case 'values': return createIterResultObject$1(target[index], false); + } return createIterResultObject$1([index, target[index]], false); +}, 'values'); + +// argumentsList[@@iterator] is %ArrayProto_values% +// https://tc39.es/ecma262/#sec-createunmappedargumentsobject +// https://tc39.es/ecma262/#sec-createmappedargumentsobject +var values = Iterators.Arguments = Iterators.Array; + +// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables +addToUnscopables('keys'); +addToUnscopables('values'); +addToUnscopables('entries'); + +// V8 ~ Chrome 45- bug +if (DESCRIPTORS && values.name !== 'values') try { + defineProperty$1(values, 'name', { value: 'values' }); +} catch (error) { /* empty */ } + +var classof$2 = classof$7; + +var $String = String; + +var toString$2 = function (argument) { + if (classof$2(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string'); + return $String(argument); +}; + +var uncurryThis$4 = functionUncurryThis; +var toIntegerOrInfinity = toIntegerOrInfinity$3; +var toString$1 = toString$2; +var requireObjectCoercible = requireObjectCoercible$3; + +var charAt$1 = uncurryThis$4(''.charAt); +var charCodeAt = uncurryThis$4(''.charCodeAt); +var stringSlice = uncurryThis$4(''.slice); + +var createMethod$1 = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = toString$1(requireObjectCoercible($this)); + var position = toIntegerOrInfinity(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = charCodeAt(S, position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt$1(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; +}; + +var stringMultibyte = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod$1(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod$1(true) +}; + +var charAt = stringMultibyte.charAt; +var toString = toString$2; +var InternalStateModule$1 = internalState; +var defineIterator = iteratorDefine; +var createIterResultObject = createIterResultObject$2; + +var STRING_ITERATOR = 'String Iterator'; +var setInternalState$1 = InternalStateModule$1.set; +var getInternalState = InternalStateModule$1.getterFor(STRING_ITERATOR); + +// `String.prototype[@@iterator]` method +// https://tc39.es/ecma262/#sec-string.prototype-@@iterator +defineIterator(String, 'String', function (iterated) { + setInternalState$1(this, { + type: STRING_ITERATOR, + string: toString(iterated), + index: 0 + }); +// `%StringIteratorPrototype%.next` method +// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next +}, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return createIterResultObject(undefined, true); + point = charAt(string, index); + state.index += point.length; + return createIterResultObject(point, false); +}); + +var internalMetadata = {exports: {}}; + +var objectGetOwnPropertyNamesExternal = {}; + +var toAbsoluteIndex = toAbsoluteIndex$2; +var lengthOfArrayLike$1 = lengthOfArrayLike$5; +var createProperty = createProperty$2; + +var $Array = Array; +var max = Math.max; + +var arraySliceSimple = function (O, start, end) { + var length = lengthOfArrayLike$1(O); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + var result = $Array(max(fin - k, 0)); + var n = 0; + for (; k < fin; k++, n++) createProperty(result, n, O[k]); + result.length = n; + return result; +}; + +/* eslint-disable es/no-object-getownpropertynames -- safe */ +var classof$1 = classofRaw$2; +var toIndexedObject = toIndexedObject$6; +var $getOwnPropertyNames = objectGetOwnPropertyNames.f; +var arraySlice = arraySliceSimple; + +var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + +var getWindowNames = function (it) { + try { + return $getOwnPropertyNames(it); + } catch (error) { + return arraySlice(windowNames); + } +}; + +// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window +objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames(it) { + return windowNames && classof$1(it) === 'Window' + ? getWindowNames(it) + : $getOwnPropertyNames(toIndexedObject(it)); +}; + +// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it +var fails$3 = fails$j; + +var arrayBufferNonExtensible = fails$3(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } +}); + +var fails$2 = fails$j; +var isObject$4 = isObject$f; +var classof = classofRaw$2; +var ARRAY_BUFFER_NON_EXTENSIBLE = arrayBufferNonExtensible; + +// eslint-disable-next-line es/no-object-isextensible -- safe +var $isExtensible = Object.isExtensible; +var FAILS_ON_PRIMITIVES = fails$2(function () { $isExtensible(1); }); + +// `Object.isExtensible` method +// https://tc39.es/ecma262/#sec-object.isextensible +var objectIsExtensible = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) { + if (!isObject$4(it)) return false; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false; + return $isExtensible ? $isExtensible(it) : true; +} : $isExtensible; + +var fails$1 = fails$j; + +var freezing = !fails$1(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); +}); + +var $$1 = _export; +var uncurryThis$3 = functionUncurryThis; +var hiddenKeys = hiddenKeys$5; +var isObject$3 = isObject$f; +var hasOwn$1 = hasOwnProperty_1; +var defineProperty = objectDefineProperty.f; +var getOwnPropertyNamesModule = objectGetOwnPropertyNames; +var getOwnPropertyNamesExternalModule = objectGetOwnPropertyNamesExternal; +var isExtensible = objectIsExtensible; +var uid = uid$3; +var FREEZING = freezing; + +var REQUIRED = false; +var METADATA = uid('meta'); +var id$1 = 0; + +var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + id$1++, // object ID + weakData: {} // weak collections IDs + } }); +}; + +var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject$3(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; +}; + +var getWeakData$1 = function (it, create) { + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; +}; + +// add metadata on freeze-family methods calling +var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn$1(it, METADATA)) setMetadata(it); + return it; +}; + +var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis$3([].splice); + var test = {}; + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $$1({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } +}; + +var meta = internalMetadata.exports = { + enable: enable, + fastKey: fastKey, + getWeakData: getWeakData$1, + onFreeze: onFreeze +}; + +hiddenKeys[METADATA] = true; + +var internalMetadataExports = internalMetadata.exports; + +var isCallable$1 = isCallable$m; +var isObject$2 = isObject$f; +var setPrototypeOf = objectSetPrototypeOf; + +// makes subclassing work correct for wrapped built-ins +var inheritIfRequired$1 = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable$1(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject$2(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; +}; + +var $ = _export; +var global$2 = global$j; +var uncurryThis$2 = functionUncurryThis; +var isForced = isForced_1; +var defineBuiltIn$1 = defineBuiltIn$8; +var InternalMetadataModule = internalMetadataExports; +var iterate$1 = iterate$4; +var anInstance$1 = anInstance$3; +var isCallable = isCallable$m; +var isNullOrUndefined$1 = isNullOrUndefined$6; +var isObject$1 = isObject$f; +var fails = fails$j; +var checkCorrectnessOfIteration = checkCorrectnessOfIteration$2; +var setToStringTag$1 = setToStringTag$5; +var inheritIfRequired = inheritIfRequired$1; + +var collection$1 = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global$2[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis$2(NativePrototype[KEY]); + defineBuiltIn$1(NativePrototype, KEY, + KEY === 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY === 'delete' ? function (key) { + return IS_WEAK && !isObject$1(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'get' ? function get(key) { + return IS_WEAK && !isObject$1(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'has' ? function has(key) { + return IS_WEAK && !isObject$1(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance$1(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (!isNullOrUndefined$1(iterable)) iterate$1(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported); + + setToStringTag$1(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; +}; + +var defineBuiltIn = defineBuiltIn$8; + +var defineBuiltIns$1 = function (target, src, options) { + for (var key in src) defineBuiltIn(target, key, src[key], options); + return target; +}; + +var bind = functionBindContext; +var uncurryThis$1 = functionUncurryThis; +var IndexedObject = indexedObject; +var toObject = toObject$5; +var lengthOfArrayLike = lengthOfArrayLike$5; +var arraySpeciesCreate = arraySpeciesCreate$2; + +var push = uncurryThis$1([].push); + +// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation +var createMethod = function (TYPE) { + var IS_MAP = TYPE === 1; + var IS_FILTER = TYPE === 2; + var IS_SOME = TYPE === 3; + var IS_EVERY = TYPE === 4; + var IS_FIND_INDEX = TYPE === 6; + var IS_FILTER_REJECT = TYPE === 7; + var NO_HOLES = TYPE === 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject($this); + var self = IndexedObject(O); + var length = lengthOfArrayLike(self); + var boundFunction = bind(callbackfn, that); + var index = 0; + var create = specificCreate || arraySpeciesCreate; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push(target, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; +}; + +var arrayIteration = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod(7) +}; + +var uncurryThis = functionUncurryThis; +var defineBuiltIns = defineBuiltIns$1; +var getWeakData = internalMetadataExports.getWeakData; +var anInstance = anInstance$3; +var anObject = anObject$b; +var isNullOrUndefined = isNullOrUndefined$6; +var isObject = isObject$f; +var iterate = iterate$4; +var ArrayIterationModule = arrayIteration; +var hasOwn = hasOwnProperty_1; +var InternalStateModule = internalState; + +var setInternalState = InternalStateModule.set; +var internalStateGetterFor = InternalStateModule.getterFor; +var find = ArrayIterationModule.find; +var findIndex = ArrayIterationModule.findIndex; +var splice = uncurryThis([].splice); +var id = 0; + +// fallback for uncaught frozen keys +var uncaughtFrozenStore = function (state) { + return state.frozen || (state.frozen = new UncaughtFrozenStore()); +}; + +var UncaughtFrozenStore = function () { + this.entries = []; +}; + +var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); +}; + +UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) splice(this.entries, index, 1); + return !!~index; + } +}; + +var collectionWeak$1 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + defineBuiltIns(Prototype, { + // `{ WeakMap, WeakSet }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.delete + // https://tc39.es/ecma262/#sec-weakset.prototype.delete + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && hasOwn(data, state.id) && delete data[state.id]; + }, + // `{ WeakMap, WeakSet }.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.has + // https://tc39.es/ecma262/#sec-weakset.prototype.has + has: function has(key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && hasOwn(data, state.id); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `WeakMap.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.get + get: function get(key) { + var state = getInternalState(this); + if (isObject(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // `WeakMap.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.set + set: function set(key, value) { + return define(this, key, value); + } + } : { + // `WeakSet.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-weakset.prototype.add + add: function add(value) { + return define(this, value, true); + } + }); + + return Constructor; + } +}; + +var collection = collection$1; +var collectionWeak = collectionWeak$1; + +// `WeakSet` constructor +// https://tc39.es/ecma262/#sec-weakset-constructor +collection('WeakSet', function (init) { + return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); }; +}, collectionWeak); + +// iterable DOM collections +// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods +var domIterables = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 +}; + +// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList` +var documentCreateElement = documentCreateElement$2; + +var classList = documentCreateElement('span').classList; +var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype; + +var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1; + +var global$1 = global$j; +var DOMIterables = domIterables; +var DOMTokenListPrototype = domTokenListPrototype; +var ArrayIteratorMethods = es_array_iterator; +var createNonEnumerableProperty = createNonEnumerableProperty$4; +var setToStringTag = setToStringTag$5; +var wellKnownSymbol = wellKnownSymbol$h; + +var ITERATOR = wellKnownSymbol('iterator'); +var ArrayValues = ArrayIteratorMethods.values; + +var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + setToStringTag(CollectionPrototype, COLLECTION_NAME, true); + if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } +}; + +for (var COLLECTION_NAME in DOMIterables) { + handlePrototype(global$1[COLLECTION_NAME] && global$1[COLLECTION_NAME].prototype, COLLECTION_NAME); +} + +handlePrototype(DOMTokenListPrototype, 'DOMTokenList'); + +/****************************************************************************** +Copyright (c) Microsoft Corporation. + +Permission to use, copy, modify, and/or distribute this software for any +purpose with or without fee is hereby granted. + +THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH +REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, +INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM +LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR +OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR +PERFORMANCE OF THIS SOFTWARE. +***************************************************************************** */ +/* global Reflect, Promise */ + + +function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); +} + +var _Tooltip_instances, _Tooltip_show, _Tooltip_hide; +var DEFAULT_SELECTOR = '#ch-tooltip'; +var defaultOptions = { + enabled: true, + // Expecting a function, which will return the tooltip content + text: function text(_timestamp, value, dayjsDate) { + return (// eslint-disable-next-line implicit-arrow-linebreak + "".concat(value, " - ").concat(dayjsDate.format('LLLL')) + ); + } +}; +var DEFAULT_POPPER_OPTIONS = { + placement: 'top', + modifiers: [{ + name: 'offset', + options: { + offset: [0, 8] + } + }] +}; +var virtualElement = { + getBoundingClientRect: function getBoundingClientRect() { + var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; + var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + return { + width: 0, + height: 0, + top: y, + right: x, + bottom: y, + left: x, + x: x, + y: y, + toJSON: function toJSON() {} + }; + } +}; +var Tooltip = /*#__PURE__*/function () { + function Tooltip(calendar) { + _classCallCheck(this, Tooltip); + _Tooltip_instances.add(this); + this.name = 'Tooltip'; + this.calendar = calendar; + this.root = null; + this.popperInstance = null; + this.options = defaultOptions; + this.listenerAttached = false; + } + _createClass(Tooltip, [{ + key: "setup", + value: function setup(pluginOptions) { + this.options = Object.assign(Object.assign({}, defaultOptions), pluginOptions); + var event = this.calendar.eventEmitter; + if (!this.options.enabled) { + if (this.listenerAttached) { + event.off('mouseover', this.mouseOverCallback, this); + event.off('mouseout', this.mouseOutCallback, this); + this.listenerAttached = false; + } + this.destroy(); + return; + } + this.popperOptions = Object.assign(Object.assign({}, DEFAULT_POPPER_OPTIONS), this.options); + this.root = document.getElementById(DEFAULT_SELECTOR.slice(1)); + if (!this.root) { + var tooltipElem = document.createElement('div'); + tooltipElem.setAttribute('id', DEFAULT_SELECTOR.slice(1)); + tooltipElem.setAttribute('role', 'tooltip'); + tooltipElem.innerHTML = "
") + ""); + this.root = document.body.appendChild(tooltipElem); + } + this.root.setAttribute('data-theme', this.calendar.options.options.theme); + this.popperInstance = createPopper(virtualElement, this.root, this.popperOptions); + if (!this.listenerAttached) { + event.on('mouseover', this.mouseOverCallback, this); + event.on('mouseout', this.mouseOutCallback, this); + this.listenerAttached = true; + } + } + }, { + key: "mouseOverCallback", + value: function mouseOverCallback(e, timestamp, value) { + __classPrivateFieldGet(this, _Tooltip_instances, "m", _Tooltip_show).call(this, e.target, timestamp, value); + } + }, { + key: "mouseOutCallback", + value: function mouseOutCallback() { + __classPrivateFieldGet(this, _Tooltip_instances, "m", _Tooltip_hide).call(this); + } + // eslint-disable-next-line class-methods-use-this + }, { + key: "paint", + value: function paint() { + return Promise.resolve(); + } + }, { + key: "destroy", + value: function destroy() { + if (this.root) { + this.root.remove(); + } + return Promise.resolve(); + } + }]); + return Tooltip; +}(); +_Tooltip_instances = new WeakSet(), _Tooltip_show = function _Tooltip_show(e, timestamp, value) { + var _this = this; + var formatter = this.options.text; + var title = formatter ? formatter(timestamp, value, this.calendar.dateHelper.date(timestamp)) : null; + if (!title) { + return; + } + virtualElement.getBoundingClientRect = function () { + return e.getBoundingClientRect(); + }; + document.getElementById("".concat(DEFAULT_SELECTOR.slice(1), "-body")).innerHTML = title; + this.popperInstance.setOptions(function () { + return Object.assign(Object.assign({}, _this.popperOptions), { + modifiers: [].concat(_toConsumableArray(_this.popperOptions.modifiers), [{ + name: 'eventListeners', + enabled: true + }]) + }); + }); + this.popperInstance.update(); + this.root.setAttribute('data-show', '1'); +}, _Tooltip_hide = function _Tooltip_hide() { + var _this2 = this; + this.root.removeAttribute('data-show'); + this.popperInstance.setOptions(function () { + return Object.assign(Object.assign({}, _this2.popperOptions), { + modifiers: [].concat(_toConsumableArray(_this2.popperOptions.modifiers), [{ + name: 'eventListeners', + enabled: false + }]) + }); + }); +}; + +export { Tooltip as default }; diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.js b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.js new file mode 100644 index 0000000..3e56518 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.js @@ -0,0 +1,3774 @@ +(function (global, factory) { + typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory(require('@popperjs/core')) : + typeof define === 'function' && define.amd ? define(['@popperjs/core'], factory) : + (global = typeof globalThis !== 'undefined' ? globalThis : global || self, global.Tooltip = factory(global.Popper)); +})(this, (function (core) { 'use strict'; + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); + } + } + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + Object.defineProperty(Constructor, "prototype", { + writable: false + }); + return Constructor; + } + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter); + } + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + return arr2; + } + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + return (hint === "string" ? String : Number)(input); + } + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + return typeof key === "symbol" ? key : String(key); + } + + var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {}; + + var check = function (it) { + return it && it.Math === Math && it; + }; + + // https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 + var global$j = + // eslint-disable-next-line es/no-global-this -- safe + check(typeof globalThis == 'object' && globalThis) || + check(typeof window == 'object' && window) || + // eslint-disable-next-line no-restricted-globals -- safe + check(typeof self == 'object' && self) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + check(typeof commonjsGlobal == 'object' && commonjsGlobal) || + // eslint-disable-next-line no-new-func -- fallback + (function () { return this; })() || Function('return this')(); + + var objectGetOwnPropertyDescriptor = {}; + + var fails$j = function (exec) { + try { + return !!exec(); + } catch (error) { + return true; + } + }; + + var fails$i = fails$j; + + // Detect IE8's incomplete defineProperty implementation + var descriptors = !fails$i(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7; + }); + + var fails$h = fails$j; + + var functionBindNative = !fails$h(function () { + // eslint-disable-next-line es/no-function-prototype-bind -- safe + var test = (function () { /* empty */ }).bind(); + // eslint-disable-next-line no-prototype-builtins -- safe + return typeof test != 'function' || test.hasOwnProperty('prototype'); + }); + + var NATIVE_BIND$3 = functionBindNative; + + var call$e = Function.prototype.call; + + var functionCall = NATIVE_BIND$3 ? call$e.bind(call$e) : function () { + return call$e.apply(call$e, arguments); + }; + + var objectPropertyIsEnumerable = {}; + + var $propertyIsEnumerable = {}.propertyIsEnumerable; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getOwnPropertyDescriptor$2 = Object.getOwnPropertyDescriptor; + + // Nashorn ~ JDK8 bug + var NASHORN_BUG = getOwnPropertyDescriptor$2 && !$propertyIsEnumerable.call({ 1: 2 }, 1); + + // `Object.prototype.propertyIsEnumerable` method implementation + // https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable + objectPropertyIsEnumerable.f = NASHORN_BUG ? function propertyIsEnumerable(V) { + var descriptor = getOwnPropertyDescriptor$2(this, V); + return !!descriptor && descriptor.enumerable; + } : $propertyIsEnumerable; + + var createPropertyDescriptor$4 = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; + }; + + var NATIVE_BIND$2 = functionBindNative; + + var FunctionPrototype$3 = Function.prototype; + var call$d = FunctionPrototype$3.call; + var uncurryThisWithBind = NATIVE_BIND$2 && FunctionPrototype$3.bind.bind(call$d, call$d); + + var functionUncurryThis = NATIVE_BIND$2 ? uncurryThisWithBind : function (fn) { + return function () { + return call$d.apply(fn, arguments); + }; + }; + + var uncurryThis$k = functionUncurryThis; + + var toString$5 = uncurryThis$k({}.toString); + var stringSlice$2 = uncurryThis$k(''.slice); + + var classofRaw$2 = function (it) { + return stringSlice$2(toString$5(it), 8, -1); + }; + + var uncurryThis$j = functionUncurryThis; + var fails$g = fails$j; + var classof$9 = classofRaw$2; + + var $Object$4 = Object; + var split = uncurryThis$j(''.split); + + // fallback for non-array-like ES3 and non-enumerable old V8 strings + var indexedObject = fails$g(function () { + // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346 + // eslint-disable-next-line no-prototype-builtins -- safe + return !$Object$4('z').propertyIsEnumerable(0); + }) ? function (it) { + return classof$9(it) === 'String' ? split(it, '') : $Object$4(it); + } : $Object$4; + + // we can't use just `it == null` since of `document.all` special case + // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec + var isNullOrUndefined$6 = function (it) { + return it === null || it === undefined; + }; + + var isNullOrUndefined$5 = isNullOrUndefined$6; + + var $TypeError$d = TypeError; + + // `RequireObjectCoercible` abstract operation + // https://tc39.es/ecma262/#sec-requireobjectcoercible + var requireObjectCoercible$3 = function (it) { + if (isNullOrUndefined$5(it)) throw new $TypeError$d("Can't call method on " + it); + return it; + }; + + // toObject with fallback for non-array-like ES3 strings + var IndexedObject$2 = indexedObject; + var requireObjectCoercible$2 = requireObjectCoercible$3; + + var toIndexedObject$6 = function (it) { + return IndexedObject$2(requireObjectCoercible$2(it)); + }; + + var documentAll$2 = typeof document == 'object' && document.all; + + // https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot + // eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing + var IS_HTMLDDA = typeof documentAll$2 == 'undefined' && documentAll$2 !== undefined; + + var documentAll_1 = { + all: documentAll$2, + IS_HTMLDDA: IS_HTMLDDA + }; + + var $documentAll$1 = documentAll_1; + + var documentAll$1 = $documentAll$1.all; + + // `IsCallable` abstract operation + // https://tc39.es/ecma262/#sec-iscallable + var isCallable$m = $documentAll$1.IS_HTMLDDA ? function (argument) { + return typeof argument == 'function' || argument === documentAll$1; + } : function (argument) { + return typeof argument == 'function'; + }; + + var isCallable$l = isCallable$m; + var $documentAll = documentAll_1; + + var documentAll = $documentAll.all; + + var isObject$f = $documentAll.IS_HTMLDDA ? function (it) { + return typeof it == 'object' ? it !== null : isCallable$l(it) || it === documentAll; + } : function (it) { + return typeof it == 'object' ? it !== null : isCallable$l(it); + }; + + var global$i = global$j; + var isCallable$k = isCallable$m; + + var aFunction = function (argument) { + return isCallable$k(argument) ? argument : undefined; + }; + + var getBuiltIn$7 = function (namespace, method) { + return arguments.length < 2 ? aFunction(global$i[namespace]) : global$i[namespace] && global$i[namespace][method]; + }; + + var uncurryThis$i = functionUncurryThis; + + var objectIsPrototypeOf = uncurryThis$i({}.isPrototypeOf); + + var engineUserAgent = typeof navigator != 'undefined' && String(navigator.userAgent) || ''; + + var global$h = global$j; + var userAgent$3 = engineUserAgent; + + var process$3 = global$h.process; + var Deno$1 = global$h.Deno; + var versions = process$3 && process$3.versions || Deno$1 && Deno$1.version; + var v8 = versions && versions.v8; + var match, version; + + if (v8) { + match = v8.split('.'); + // in old Chrome, versions of V8 isn't V8 = Chrome / 10 + // but their correct versions are not interesting for us + version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]); + } + + // BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0` + // so check `userAgent` even if `.v8` exists, but 0 + if (!version && userAgent$3) { + match = userAgent$3.match(/Edge\/(\d+)/); + if (!match || match[1] >= 74) { + match = userAgent$3.match(/Chrome\/(\d+)/); + if (match) version = +match[1]; + } + } + + var engineV8Version = version; + + /* eslint-disable es/no-symbol -- required for testing */ + var V8_VERSION$3 = engineV8Version; + var fails$f = fails$j; + var global$g = global$j; + + var $String$5 = global$g.String; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing + var symbolConstructorDetection = !!Object.getOwnPropertySymbols && !fails$f(function () { + var symbol = Symbol('symbol detection'); + // Chrome 38 Symbol has incorrect toString conversion + // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances + // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will, + // of course, fail. + return !$String$5(symbol) || !(Object(symbol) instanceof Symbol) || + // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances + !Symbol.sham && V8_VERSION$3 && V8_VERSION$3 < 41; + }); + + /* eslint-disable es/no-symbol -- required for testing */ + var NATIVE_SYMBOL$1 = symbolConstructorDetection; + + var useSymbolAsUid = NATIVE_SYMBOL$1 + && !Symbol.sham + && typeof Symbol.iterator == 'symbol'; + + var getBuiltIn$6 = getBuiltIn$7; + var isCallable$j = isCallable$m; + var isPrototypeOf$2 = objectIsPrototypeOf; + var USE_SYMBOL_AS_UID$1 = useSymbolAsUid; + + var $Object$3 = Object; + + var isSymbol$2 = USE_SYMBOL_AS_UID$1 ? function (it) { + return typeof it == 'symbol'; + } : function (it) { + var $Symbol = getBuiltIn$6('Symbol'); + return isCallable$j($Symbol) && isPrototypeOf$2($Symbol.prototype, $Object$3(it)); + }; + + var $String$4 = String; + + var tryToString$4 = function (argument) { + try { + return $String$4(argument); + } catch (error) { + return 'Object'; + } + }; + + var isCallable$i = isCallable$m; + var tryToString$3 = tryToString$4; + + var $TypeError$c = TypeError; + + // `Assert: IsCallable(argument) is true` + var aCallable$8 = function (argument) { + if (isCallable$i(argument)) return argument; + throw new $TypeError$c(tryToString$3(argument) + ' is not a function'); + }; + + var aCallable$7 = aCallable$8; + var isNullOrUndefined$4 = isNullOrUndefined$6; + + // `GetMethod` abstract operation + // https://tc39.es/ecma262/#sec-getmethod + var getMethod$3 = function (V, P) { + var func = V[P]; + return isNullOrUndefined$4(func) ? undefined : aCallable$7(func); + }; + + var call$c = functionCall; + var isCallable$h = isCallable$m; + var isObject$e = isObject$f; + + var $TypeError$b = TypeError; + + // `OrdinaryToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-ordinarytoprimitive + var ordinaryToPrimitive$1 = function (input, pref) { + var fn, val; + if (pref === 'string' && isCallable$h(fn = input.toString) && !isObject$e(val = call$c(fn, input))) return val; + if (isCallable$h(fn = input.valueOf) && !isObject$e(val = call$c(fn, input))) return val; + if (pref !== 'string' && isCallable$h(fn = input.toString) && !isObject$e(val = call$c(fn, input))) return val; + throw new $TypeError$b("Can't convert object to primitive value"); + }; + + var shared$3 = {exports: {}}; + + var global$f = global$j; + + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$7 = Object.defineProperty; + + var defineGlobalProperty$3 = function (key, value) { + try { + defineProperty$7(global$f, key, { value: value, configurable: true, writable: true }); + } catch (error) { + global$f[key] = value; + } return value; + }; + + var global$e = global$j; + var defineGlobalProperty$2 = defineGlobalProperty$3; + + var SHARED = '__core-js_shared__'; + var store$3 = global$e[SHARED] || defineGlobalProperty$2(SHARED, {}); + + var sharedStore = store$3; + + var store$2 = sharedStore; + + (shared$3.exports = function (key, value) { + return store$2[key] || (store$2[key] = value !== undefined ? value : {}); + })('versions', []).push({ + version: '3.34.0', + mode: 'global', + copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)', + license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE', + source: 'https://github.com/zloirock/core-js' + }); + + var sharedExports = shared$3.exports; + + var requireObjectCoercible$1 = requireObjectCoercible$3; + + var $Object$2 = Object; + + // `ToObject` abstract operation + // https://tc39.es/ecma262/#sec-toobject + var toObject$5 = function (argument) { + return $Object$2(requireObjectCoercible$1(argument)); + }; + + var uncurryThis$h = functionUncurryThis; + var toObject$4 = toObject$5; + + var hasOwnProperty = uncurryThis$h({}.hasOwnProperty); + + // `HasOwnProperty` abstract operation + // https://tc39.es/ecma262/#sec-hasownproperty + // eslint-disable-next-line es/no-object-hasown -- safe + var hasOwnProperty_1 = Object.hasOwn || function hasOwn(it, key) { + return hasOwnProperty(toObject$4(it), key); + }; + + var uncurryThis$g = functionUncurryThis; + + var id$2 = 0; + var postfix = Math.random(); + var toString$4 = uncurryThis$g(1.0.toString); + + var uid$3 = function (key) { + return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString$4(++id$2 + postfix, 36); + }; + + var global$d = global$j; + var shared$2 = sharedExports; + var hasOwn$b = hasOwnProperty_1; + var uid$2 = uid$3; + var NATIVE_SYMBOL = symbolConstructorDetection; + var USE_SYMBOL_AS_UID = useSymbolAsUid; + + var Symbol$1 = global$d.Symbol; + var WellKnownSymbolsStore = shared$2('wks'); + var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol$1['for'] || Symbol$1 : Symbol$1 && Symbol$1.withoutSetter || uid$2; + + var wellKnownSymbol$h = function (name) { + if (!hasOwn$b(WellKnownSymbolsStore, name)) { + WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn$b(Symbol$1, name) + ? Symbol$1[name] + : createWellKnownSymbol('Symbol.' + name); + } return WellKnownSymbolsStore[name]; + }; + + var call$b = functionCall; + var isObject$d = isObject$f; + var isSymbol$1 = isSymbol$2; + var getMethod$2 = getMethod$3; + var ordinaryToPrimitive = ordinaryToPrimitive$1; + var wellKnownSymbol$g = wellKnownSymbol$h; + + var $TypeError$a = TypeError; + var TO_PRIMITIVE = wellKnownSymbol$g('toPrimitive'); + + // `ToPrimitive` abstract operation + // https://tc39.es/ecma262/#sec-toprimitive + var toPrimitive$1 = function (input, pref) { + if (!isObject$d(input) || isSymbol$1(input)) return input; + var exoticToPrim = getMethod$2(input, TO_PRIMITIVE); + var result; + if (exoticToPrim) { + if (pref === undefined) pref = 'default'; + result = call$b(exoticToPrim, input, pref); + if (!isObject$d(result) || isSymbol$1(result)) return result; + throw new $TypeError$a("Can't convert object to primitive value"); + } + if (pref === undefined) pref = 'number'; + return ordinaryToPrimitive(input, pref); + }; + + var toPrimitive = toPrimitive$1; + var isSymbol = isSymbol$2; + + // `ToPropertyKey` abstract operation + // https://tc39.es/ecma262/#sec-topropertykey + var toPropertyKey$3 = function (argument) { + var key = toPrimitive(argument, 'string'); + return isSymbol(key) ? key : key + ''; + }; + + var global$c = global$j; + var isObject$c = isObject$f; + + var document$3 = global$c.document; + // typeof document.createElement is 'object' in old IE + var EXISTS$1 = isObject$c(document$3) && isObject$c(document$3.createElement); + + var documentCreateElement$2 = function (it) { + return EXISTS$1 ? document$3.createElement(it) : {}; + }; + + var DESCRIPTORS$b = descriptors; + var fails$e = fails$j; + var createElement$1 = documentCreateElement$2; + + // Thanks to IE8 for its funny defineProperty + var ie8DomDefine = !DESCRIPTORS$b && !fails$e(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(createElement$1('div'), 'a', { + get: function () { return 7; } + }).a !== 7; + }); + + var DESCRIPTORS$a = descriptors; + var call$a = functionCall; + var propertyIsEnumerableModule$1 = objectPropertyIsEnumerable; + var createPropertyDescriptor$3 = createPropertyDescriptor$4; + var toIndexedObject$5 = toIndexedObject$6; + var toPropertyKey$2 = toPropertyKey$3; + var hasOwn$a = hasOwnProperty_1; + var IE8_DOM_DEFINE$1 = ie8DomDefine; + + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor$1 = Object.getOwnPropertyDescriptor; + + // `Object.getOwnPropertyDescriptor` method + // https://tc39.es/ecma262/#sec-object.getownpropertydescriptor + objectGetOwnPropertyDescriptor.f = DESCRIPTORS$a ? $getOwnPropertyDescriptor$1 : function getOwnPropertyDescriptor(O, P) { + O = toIndexedObject$5(O); + P = toPropertyKey$2(P); + if (IE8_DOM_DEFINE$1) try { + return $getOwnPropertyDescriptor$1(O, P); + } catch (error) { /* empty */ } + if (hasOwn$a(O, P)) return createPropertyDescriptor$3(!call$a(propertyIsEnumerableModule$1.f, O, P), O[P]); + }; + + var objectDefineProperty = {}; + + var DESCRIPTORS$9 = descriptors; + var fails$d = fails$j; + + // V8 ~ Chrome 36- + // https://bugs.chromium.org/p/v8/issues/detail?id=3334 + var v8PrototypeDefineBug = DESCRIPTORS$9 && fails$d(function () { + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + return Object.defineProperty(function () { /* empty */ }, 'prototype', { + value: 42, + writable: false + }).prototype !== 42; + }); + + var isObject$b = isObject$f; + + var $String$3 = String; + var $TypeError$9 = TypeError; + + // `Assert: Type(argument) is Object` + var anObject$b = function (argument) { + if (isObject$b(argument)) return argument; + throw new $TypeError$9($String$3(argument) + ' is not an object'); + }; + + var DESCRIPTORS$8 = descriptors; + var IE8_DOM_DEFINE = ie8DomDefine; + var V8_PROTOTYPE_DEFINE_BUG$1 = v8PrototypeDefineBug; + var anObject$a = anObject$b; + var toPropertyKey$1 = toPropertyKey$3; + + var $TypeError$8 = TypeError; + // eslint-disable-next-line es/no-object-defineproperty -- safe + var $defineProperty = Object.defineProperty; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; + var ENUMERABLE = 'enumerable'; + var CONFIGURABLE$1 = 'configurable'; + var WRITABLE = 'writable'; + + // `Object.defineProperty` method + // https://tc39.es/ecma262/#sec-object.defineproperty + objectDefineProperty.f = DESCRIPTORS$8 ? V8_PROTOTYPE_DEFINE_BUG$1 ? function defineProperty(O, P, Attributes) { + anObject$a(O); + P = toPropertyKey$1(P); + anObject$a(Attributes); + if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) { + var current = $getOwnPropertyDescriptor(O, P); + if (current && current[WRITABLE]) { + O[P] = Attributes.value; + Attributes = { + configurable: CONFIGURABLE$1 in Attributes ? Attributes[CONFIGURABLE$1] : current[CONFIGURABLE$1], + enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE], + writable: false + }; + } + } return $defineProperty(O, P, Attributes); + } : $defineProperty : function defineProperty(O, P, Attributes) { + anObject$a(O); + P = toPropertyKey$1(P); + anObject$a(Attributes); + if (IE8_DOM_DEFINE) try { + return $defineProperty(O, P, Attributes); + } catch (error) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw new $TypeError$8('Accessors not supported'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; + }; + + var DESCRIPTORS$7 = descriptors; + var definePropertyModule$4 = objectDefineProperty; + var createPropertyDescriptor$2 = createPropertyDescriptor$4; + + var createNonEnumerableProperty$4 = DESCRIPTORS$7 ? function (object, key, value) { + return definePropertyModule$4.f(object, key, createPropertyDescriptor$2(1, value)); + } : function (object, key, value) { + object[key] = value; + return object; + }; + + var makeBuiltIn$3 = {exports: {}}; + + var DESCRIPTORS$6 = descriptors; + var hasOwn$9 = hasOwnProperty_1; + + var FunctionPrototype$2 = Function.prototype; + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + var getDescriptor = DESCRIPTORS$6 && Object.getOwnPropertyDescriptor; + + var EXISTS = hasOwn$9(FunctionPrototype$2, 'name'); + // additional protection from minified / mangled / dropped function names + var PROPER = EXISTS && (function something() { /* empty */ }).name === 'something'; + var CONFIGURABLE = EXISTS && (!DESCRIPTORS$6 || (DESCRIPTORS$6 && getDescriptor(FunctionPrototype$2, 'name').configurable)); + + var functionName = { + EXISTS: EXISTS, + PROPER: PROPER, + CONFIGURABLE: CONFIGURABLE + }; + + var uncurryThis$f = functionUncurryThis; + var isCallable$g = isCallable$m; + var store$1 = sharedStore; + + var functionToString$1 = uncurryThis$f(Function.toString); + + // this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper + if (!isCallable$g(store$1.inspectSource)) { + store$1.inspectSource = function (it) { + return functionToString$1(it); + }; + } + + var inspectSource$3 = store$1.inspectSource; + + var global$b = global$j; + var isCallable$f = isCallable$m; + + var WeakMap$1 = global$b.WeakMap; + + var weakMapBasicDetection = isCallable$f(WeakMap$1) && /native code/.test(String(WeakMap$1)); + + var shared$1 = sharedExports; + var uid$1 = uid$3; + + var keys = shared$1('keys'); + + var sharedKey$3 = function (key) { + return keys[key] || (keys[key] = uid$1(key)); + }; + + var hiddenKeys$5 = {}; + + var NATIVE_WEAK_MAP = weakMapBasicDetection; + var global$a = global$j; + var isObject$a = isObject$f; + var createNonEnumerableProperty$3 = createNonEnumerableProperty$4; + var hasOwn$8 = hasOwnProperty_1; + var shared = sharedStore; + var sharedKey$2 = sharedKey$3; + var hiddenKeys$4 = hiddenKeys$5; + + var OBJECT_ALREADY_INITIALIZED = 'Object already initialized'; + var TypeError$2 = global$a.TypeError; + var WeakMap = global$a.WeakMap; + var set$1, get, has; + + var enforce = function (it) { + return has(it) ? get(it) : set$1(it, {}); + }; + + var getterFor = function (TYPE) { + return function (it) { + var state; + if (!isObject$a(it) || (state = get(it)).type !== TYPE) { + throw new TypeError$2('Incompatible receiver, ' + TYPE + ' required'); + } return state; + }; + }; + + if (NATIVE_WEAK_MAP || shared.state) { + var store = shared.state || (shared.state = new WeakMap()); + /* eslint-disable no-self-assign -- prototype methods protection */ + store.get = store.get; + store.has = store.has; + store.set = store.set; + /* eslint-enable no-self-assign -- prototype methods protection */ + set$1 = function (it, metadata) { + if (store.has(it)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + store.set(it, metadata); + return metadata; + }; + get = function (it) { + return store.get(it) || {}; + }; + has = function (it) { + return store.has(it); + }; + } else { + var STATE = sharedKey$2('state'); + hiddenKeys$4[STATE] = true; + set$1 = function (it, metadata) { + if (hasOwn$8(it, STATE)) throw new TypeError$2(OBJECT_ALREADY_INITIALIZED); + metadata.facade = it; + createNonEnumerableProperty$3(it, STATE, metadata); + return metadata; + }; + get = function (it) { + return hasOwn$8(it, STATE) ? it[STATE] : {}; + }; + has = function (it) { + return hasOwn$8(it, STATE); + }; + } + + var internalState = { + set: set$1, + get: get, + has: has, + enforce: enforce, + getterFor: getterFor + }; + + var uncurryThis$e = functionUncurryThis; + var fails$c = fails$j; + var isCallable$e = isCallable$m; + var hasOwn$7 = hasOwnProperty_1; + var DESCRIPTORS$5 = descriptors; + var CONFIGURABLE_FUNCTION_NAME$1 = functionName.CONFIGURABLE; + var inspectSource$2 = inspectSource$3; + var InternalStateModule$4 = internalState; + + var enforceInternalState = InternalStateModule$4.enforce; + var getInternalState$2 = InternalStateModule$4.get; + var $String$2 = String; + // eslint-disable-next-line es/no-object-defineproperty -- safe + var defineProperty$6 = Object.defineProperty; + var stringSlice$1 = uncurryThis$e(''.slice); + var replace = uncurryThis$e(''.replace); + var join = uncurryThis$e([].join); + + var CONFIGURABLE_LENGTH = DESCRIPTORS$5 && !fails$c(function () { + return defineProperty$6(function () { /* empty */ }, 'length', { value: 8 }).length !== 8; + }); + + var TEMPLATE = String(String).split('String'); + + var makeBuiltIn$2 = makeBuiltIn$3.exports = function (value, name, options) { + if (stringSlice$1($String$2(name), 0, 7) === 'Symbol(') { + name = '[' + replace($String$2(name), /^Symbol\(([^)]*)\)/, '$1') + ']'; + } + if (options && options.getter) name = 'get ' + name; + if (options && options.setter) name = 'set ' + name; + if (!hasOwn$7(value, 'name') || (CONFIGURABLE_FUNCTION_NAME$1 && value.name !== name)) { + if (DESCRIPTORS$5) defineProperty$6(value, 'name', { value: name, configurable: true }); + else value.name = name; + } + if (CONFIGURABLE_LENGTH && options && hasOwn$7(options, 'arity') && value.length !== options.arity) { + defineProperty$6(value, 'length', { value: options.arity }); + } + try { + if (options && hasOwn$7(options, 'constructor') && options.constructor) { + if (DESCRIPTORS$5) defineProperty$6(value, 'prototype', { writable: false }); + // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable + } else if (value.prototype) value.prototype = undefined; + } catch (error) { /* empty */ } + var state = enforceInternalState(value); + if (!hasOwn$7(state, 'source')) { + state.source = join(TEMPLATE, typeof name == 'string' ? name : ''); + } return value; + }; + + // add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative + // eslint-disable-next-line no-extend-native -- required + Function.prototype.toString = makeBuiltIn$2(function toString() { + return isCallable$e(this) && getInternalState$2(this).source || inspectSource$2(this); + }, 'toString'); + + var makeBuiltInExports = makeBuiltIn$3.exports; + + var isCallable$d = isCallable$m; + var definePropertyModule$3 = objectDefineProperty; + var makeBuiltIn$1 = makeBuiltInExports; + var defineGlobalProperty$1 = defineGlobalProperty$3; + + var defineBuiltIn$8 = function (O, key, value, options) { + if (!options) options = {}; + var simple = options.enumerable; + var name = options.name !== undefined ? options.name : key; + if (isCallable$d(value)) makeBuiltIn$1(value, name, options); + if (options.global) { + if (simple) O[key] = value; + else defineGlobalProperty$1(key, value); + } else { + try { + if (!options.unsafe) delete O[key]; + else if (O[key]) simple = true; + } catch (error) { /* empty */ } + if (simple) O[key] = value; + else definePropertyModule$3.f(O, key, { + value: value, + enumerable: false, + configurable: !options.nonConfigurable, + writable: !options.nonWritable + }); + } return O; + }; + + var objectGetOwnPropertyNames = {}; + + var ceil = Math.ceil; + var floor = Math.floor; + + // `Math.trunc` method + // https://tc39.es/ecma262/#sec-math.trunc + // eslint-disable-next-line es/no-math-trunc -- safe + var mathTrunc = Math.trunc || function trunc(x) { + var n = +x; + return (n > 0 ? floor : ceil)(n); + }; + + var trunc = mathTrunc; + + // `ToIntegerOrInfinity` abstract operation + // https://tc39.es/ecma262/#sec-tointegerorinfinity + var toIntegerOrInfinity$3 = function (argument) { + var number = +argument; + // eslint-disable-next-line no-self-compare -- NaN check + return number !== number || number === 0 ? 0 : trunc(number); + }; + + var toIntegerOrInfinity$2 = toIntegerOrInfinity$3; + + var max$1 = Math.max; + var min$1 = Math.min; + + // Helper for a popular repeating case of the spec: + // Let integer be ? ToInteger(index). + // If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length). + var toAbsoluteIndex$2 = function (index, length) { + var integer = toIntegerOrInfinity$2(index); + return integer < 0 ? max$1(integer + length, 0) : min$1(integer, length); + }; + + var toIntegerOrInfinity$1 = toIntegerOrInfinity$3; + + var min = Math.min; + + // `ToLength` abstract operation + // https://tc39.es/ecma262/#sec-tolength + var toLength$1 = function (argument) { + return argument > 0 ? min(toIntegerOrInfinity$1(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991 + }; + + var toLength = toLength$1; + + // `LengthOfArrayLike` abstract operation + // https://tc39.es/ecma262/#sec-lengthofarraylike + var lengthOfArrayLike$5 = function (obj) { + return toLength(obj.length); + }; + + var toIndexedObject$4 = toIndexedObject$6; + var toAbsoluteIndex$1 = toAbsoluteIndex$2; + var lengthOfArrayLike$4 = lengthOfArrayLike$5; + + // `Array.prototype.{ indexOf, includes }` methods implementation + var createMethod$2 = function (IS_INCLUDES) { + return function ($this, el, fromIndex) { + var O = toIndexedObject$4($this); + var length = lengthOfArrayLike$4(O); + var index = toAbsoluteIndex$1(fromIndex, length); + var value; + // Array#includes uses SameValueZero equality algorithm + // eslint-disable-next-line no-self-compare -- NaN check + if (IS_INCLUDES && el !== el) while (length > index) { + value = O[index++]; + // eslint-disable-next-line no-self-compare -- NaN check + if (value !== value) return true; + // Array#indexOf ignores holes, Array#includes - not + } else for (;length > index; index++) { + if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0; + } return !IS_INCLUDES && -1; + }; + }; + + var arrayIncludes = { + // `Array.prototype.includes` method + // https://tc39.es/ecma262/#sec-array.prototype.includes + includes: createMethod$2(true), + // `Array.prototype.indexOf` method + // https://tc39.es/ecma262/#sec-array.prototype.indexof + indexOf: createMethod$2(false) + }; + + var uncurryThis$d = functionUncurryThis; + var hasOwn$6 = hasOwnProperty_1; + var toIndexedObject$3 = toIndexedObject$6; + var indexOf = arrayIncludes.indexOf; + var hiddenKeys$3 = hiddenKeys$5; + + var push$1 = uncurryThis$d([].push); + + var objectKeysInternal = function (object, names) { + var O = toIndexedObject$3(object); + var i = 0; + var result = []; + var key; + for (key in O) !hasOwn$6(hiddenKeys$3, key) && hasOwn$6(O, key) && push$1(result, key); + // Don't enum bug & hidden keys + while (names.length > i) if (hasOwn$6(O, key = names[i++])) { + ~indexOf(result, key) || push$1(result, key); + } + return result; + }; + + // IE8- don't enum bug keys + var enumBugKeys$3 = [ + 'constructor', + 'hasOwnProperty', + 'isPrototypeOf', + 'propertyIsEnumerable', + 'toLocaleString', + 'toString', + 'valueOf' + ]; + + var internalObjectKeys$1 = objectKeysInternal; + var enumBugKeys$2 = enumBugKeys$3; + + var hiddenKeys$2 = enumBugKeys$2.concat('length', 'prototype'); + + // `Object.getOwnPropertyNames` method + // https://tc39.es/ecma262/#sec-object.getownpropertynames + // eslint-disable-next-line es/no-object-getownpropertynames -- safe + objectGetOwnPropertyNames.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) { + return internalObjectKeys$1(O, hiddenKeys$2); + }; + + var objectGetOwnPropertySymbols = {}; + + // eslint-disable-next-line es/no-object-getownpropertysymbols -- safe + objectGetOwnPropertySymbols.f = Object.getOwnPropertySymbols; + + var getBuiltIn$5 = getBuiltIn$7; + var uncurryThis$c = functionUncurryThis; + var getOwnPropertyNamesModule$1 = objectGetOwnPropertyNames; + var getOwnPropertySymbolsModule$1 = objectGetOwnPropertySymbols; + var anObject$9 = anObject$b; + + var concat$1 = uncurryThis$c([].concat); + + // all object keys, includes non-enumerable and symbols + var ownKeys$1 = getBuiltIn$5('Reflect', 'ownKeys') || function ownKeys(it) { + var keys = getOwnPropertyNamesModule$1.f(anObject$9(it)); + var getOwnPropertySymbols = getOwnPropertySymbolsModule$1.f; + return getOwnPropertySymbols ? concat$1(keys, getOwnPropertySymbols(it)) : keys; + }; + + var hasOwn$5 = hasOwnProperty_1; + var ownKeys = ownKeys$1; + var getOwnPropertyDescriptorModule = objectGetOwnPropertyDescriptor; + var definePropertyModule$2 = objectDefineProperty; + + var copyConstructorProperties$1 = function (target, source, exceptions) { + var keys = ownKeys(source); + var defineProperty = definePropertyModule$2.f; + var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f; + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + if (!hasOwn$5(target, key) && !(exceptions && hasOwn$5(exceptions, key))) { + defineProperty(target, key, getOwnPropertyDescriptor(source, key)); + } + } + }; + + var fails$b = fails$j; + var isCallable$c = isCallable$m; + + var replacement = /#|\.prototype\./; + + var isForced$3 = function (feature, detection) { + var value = data[normalize(feature)]; + return value === POLYFILL ? true + : value === NATIVE ? false + : isCallable$c(detection) ? fails$b(detection) + : !!detection; + }; + + var normalize = isForced$3.normalize = function (string) { + return String(string).replace(replacement, '.').toLowerCase(); + }; + + var data = isForced$3.data = {}; + var NATIVE = isForced$3.NATIVE = 'N'; + var POLYFILL = isForced$3.POLYFILL = 'P'; + + var isForced_1 = isForced$3; + + var global$9 = global$j; + var getOwnPropertyDescriptor$1 = objectGetOwnPropertyDescriptor.f; + var createNonEnumerableProperty$2 = createNonEnumerableProperty$4; + var defineBuiltIn$7 = defineBuiltIn$8; + var defineGlobalProperty = defineGlobalProperty$3; + var copyConstructorProperties = copyConstructorProperties$1; + var isForced$2 = isForced_1; + + /* + options.target - name of the target object + options.global - target is the global object + options.stat - export as static methods of target + options.proto - export as prototype methods of target + options.real - real prototype method for the `pure` version + options.forced - export even if the native feature is available + options.bind - bind methods to the target, required for the `pure` version + options.wrap - wrap constructors to preventing global pollution, required for the `pure` version + options.unsafe - use the simple assignment of property instead of delete + defineProperty + options.sham - add a flag to not completely full polyfills + options.enumerable - export as enumerable property + options.dontCallGetSet - prevent calling a getter on target + options.name - the .name of the function if it does not match the key + */ + var _export = function (options, source) { + var TARGET = options.target; + var GLOBAL = options.global; + var STATIC = options.stat; + var FORCED, target, key, targetProperty, sourceProperty, descriptor; + if (GLOBAL) { + target = global$9; + } else if (STATIC) { + target = global$9[TARGET] || defineGlobalProperty(TARGET, {}); + } else { + target = (global$9[TARGET] || {}).prototype; + } + if (target) for (key in source) { + sourceProperty = source[key]; + if (options.dontCallGetSet) { + descriptor = getOwnPropertyDescriptor$1(target, key); + targetProperty = descriptor && descriptor.value; + } else targetProperty = target[key]; + FORCED = isForced$2(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced); + // contained in target + if (!FORCED && targetProperty !== undefined) { + if (typeof sourceProperty == typeof targetProperty) continue; + copyConstructorProperties(sourceProperty, targetProperty); + } + // add a flag to not completely full polyfills + if (options.sham || (targetProperty && targetProperty.sham)) { + createNonEnumerableProperty$2(sourceProperty, 'sham', true); + } + defineBuiltIn$7(target, key, sourceProperty, options); + } + }; + + var classof$8 = classofRaw$2; + + // `IsArray` abstract operation + // https://tc39.es/ecma262/#sec-isarray + // eslint-disable-next-line es/no-array-isarray -- safe + var isArray$2 = Array.isArray || function isArray(argument) { + return classof$8(argument) === 'Array'; + }; + + var $TypeError$7 = TypeError; + var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991 + + var doesNotExceedSafeInteger$1 = function (it) { + if (it > MAX_SAFE_INTEGER) throw $TypeError$7('Maximum allowed index exceeded'); + return it; + }; + + var toPropertyKey = toPropertyKey$3; + var definePropertyModule$1 = objectDefineProperty; + var createPropertyDescriptor$1 = createPropertyDescriptor$4; + + var createProperty$2 = function (object, key, value) { + var propertyKey = toPropertyKey(key); + if (propertyKey in object) definePropertyModule$1.f(object, propertyKey, createPropertyDescriptor$1(0, value)); + else object[propertyKey] = value; + }; + + var wellKnownSymbol$f = wellKnownSymbol$h; + + var TO_STRING_TAG$2 = wellKnownSymbol$f('toStringTag'); + var test = {}; + + test[TO_STRING_TAG$2] = 'z'; + + var toStringTagSupport = String(test) === '[object z]'; + + var TO_STRING_TAG_SUPPORT$2 = toStringTagSupport; + var isCallable$b = isCallable$m; + var classofRaw$1 = classofRaw$2; + var wellKnownSymbol$e = wellKnownSymbol$h; + + var TO_STRING_TAG$1 = wellKnownSymbol$e('toStringTag'); + var $Object$1 = Object; + + // ES3 wrong here + var CORRECT_ARGUMENTS = classofRaw$1(function () { return arguments; }()) === 'Arguments'; + + // fallback for IE11 Script Access Denied error + var tryGet = function (it, key) { + try { + return it[key]; + } catch (error) { /* empty */ } + }; + + // getting tag from ES6+ `Object.prototype.toString` + var classof$7 = TO_STRING_TAG_SUPPORT$2 ? classofRaw$1 : function (it) { + var O, tag, result; + return it === undefined ? 'Undefined' : it === null ? 'Null' + // @@toStringTag case + : typeof (tag = tryGet(O = $Object$1(it), TO_STRING_TAG$1)) == 'string' ? tag + // builtinTag case + : CORRECT_ARGUMENTS ? classofRaw$1(O) + // ES3 arguments fallback + : (result = classofRaw$1(O)) === 'Object' && isCallable$b(O.callee) ? 'Arguments' : result; + }; + + var uncurryThis$b = functionUncurryThis; + var fails$a = fails$j; + var isCallable$a = isCallable$m; + var classof$6 = classof$7; + var getBuiltIn$4 = getBuiltIn$7; + var inspectSource$1 = inspectSource$3; + + var noop = function () { /* empty */ }; + var empty = []; + var construct = getBuiltIn$4('Reflect', 'construct'); + var constructorRegExp = /^\s*(?:class|function)\b/; + var exec = uncurryThis$b(constructorRegExp.exec); + var INCORRECT_TO_STRING = !constructorRegExp.test(noop); + + var isConstructorModern = function isConstructor(argument) { + if (!isCallable$a(argument)) return false; + try { + construct(noop, empty, argument); + return true; + } catch (error) { + return false; + } + }; + + var isConstructorLegacy = function isConstructor(argument) { + if (!isCallable$a(argument)) return false; + switch (classof$6(argument)) { + case 'AsyncFunction': + case 'GeneratorFunction': + case 'AsyncGeneratorFunction': return false; + } + try { + // we can't check .prototype since constructors produced by .bind haven't it + // `Function#toString` throws on some built-it function in some legacy engines + // (for example, `DOMQuad` and similar in FF41-) + return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource$1(argument)); + } catch (error) { + return true; + } + }; + + isConstructorLegacy.sham = true; + + // `IsConstructor` abstract operation + // https://tc39.es/ecma262/#sec-isconstructor + var isConstructor$2 = !construct || fails$a(function () { + var called; + return isConstructorModern(isConstructorModern.call) + || !isConstructorModern(Object) + || !isConstructorModern(function () { called = true; }) + || called; + }) ? isConstructorLegacy : isConstructorModern; + + var isArray$1 = isArray$2; + var isConstructor$1 = isConstructor$2; + var isObject$9 = isObject$f; + var wellKnownSymbol$d = wellKnownSymbol$h; + + var SPECIES$4 = wellKnownSymbol$d('species'); + var $Array$1 = Array; + + // a part of `ArraySpeciesCreate` abstract operation + // https://tc39.es/ecma262/#sec-arrayspeciescreate + var arraySpeciesConstructor$1 = function (originalArray) { + var C; + if (isArray$1(originalArray)) { + C = originalArray.constructor; + // cross-realm fallback + if (isConstructor$1(C) && (C === $Array$1 || isArray$1(C.prototype))) C = undefined; + else if (isObject$9(C)) { + C = C[SPECIES$4]; + if (C === null) C = undefined; + } + } return C === undefined ? $Array$1 : C; + }; + + var arraySpeciesConstructor = arraySpeciesConstructor$1; + + // `ArraySpeciesCreate` abstract operation + // https://tc39.es/ecma262/#sec-arrayspeciescreate + var arraySpeciesCreate$2 = function (originalArray, length) { + return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length); + }; + + var fails$9 = fails$j; + var wellKnownSymbol$c = wellKnownSymbol$h; + var V8_VERSION$2 = engineV8Version; + + var SPECIES$3 = wellKnownSymbol$c('species'); + + var arrayMethodHasSpeciesSupport$1 = function (METHOD_NAME) { + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/677 + return V8_VERSION$2 >= 51 || !fails$9(function () { + var array = []; + var constructor = array.constructor = {}; + constructor[SPECIES$3] = function () { + return { foo: 1 }; + }; + return array[METHOD_NAME](Boolean).foo !== 1; + }); + }; + + var $$a = _export; + var fails$8 = fails$j; + var isArray = isArray$2; + var isObject$8 = isObject$f; + var toObject$3 = toObject$5; + var lengthOfArrayLike$3 = lengthOfArrayLike$5; + var doesNotExceedSafeInteger = doesNotExceedSafeInteger$1; + var createProperty$1 = createProperty$2; + var arraySpeciesCreate$1 = arraySpeciesCreate$2; + var arrayMethodHasSpeciesSupport = arrayMethodHasSpeciesSupport$1; + var wellKnownSymbol$b = wellKnownSymbol$h; + var V8_VERSION$1 = engineV8Version; + + var IS_CONCAT_SPREADABLE = wellKnownSymbol$b('isConcatSpreadable'); + + // We can't use this feature detection in V8 since it causes + // deoptimization and serious performance degradation + // https://github.com/zloirock/core-js/issues/679 + var IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION$1 >= 51 || !fails$8(function () { + var array = []; + array[IS_CONCAT_SPREADABLE] = false; + return array.concat()[0] !== array; + }); + + var isConcatSpreadable = function (O) { + if (!isObject$8(O)) return false; + var spreadable = O[IS_CONCAT_SPREADABLE]; + return spreadable !== undefined ? !!spreadable : isArray(O); + }; + + var FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat'); + + // `Array.prototype.concat` method + // https://tc39.es/ecma262/#sec-array.prototype.concat + // with adding support of @@isConcatSpreadable and @@species + $$a({ target: 'Array', proto: true, arity: 1, forced: FORCED }, { + // eslint-disable-next-line no-unused-vars -- required for `.length` + concat: function concat(arg) { + var O = toObject$3(this); + var A = arraySpeciesCreate$1(O, 0); + var n = 0; + var i, k, length, len, E; + for (i = -1, length = arguments.length; i < length; i++) { + E = i === -1 ? O : arguments[i]; + if (isConcatSpreadable(E)) { + len = lengthOfArrayLike$3(E); + doesNotExceedSafeInteger(n + len); + for (k = 0; k < len; k++, n++) if (k in E) createProperty$1(A, n, E[k]); + } else { + doesNotExceedSafeInteger(n + 1); + createProperty$1(A, n++, E); + } + } + A.length = n; + return A; + } + }); + + var makeBuiltIn = makeBuiltInExports; + var defineProperty$5 = objectDefineProperty; + + var defineBuiltInAccessor$2 = function (target, name, descriptor) { + if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true }); + if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true }); + return defineProperty$5.f(target, name, descriptor); + }; + + var DESCRIPTORS$4 = descriptors; + var FUNCTION_NAME_EXISTS = functionName.EXISTS; + var uncurryThis$a = functionUncurryThis; + var defineBuiltInAccessor$1 = defineBuiltInAccessor$2; + + var FunctionPrototype$1 = Function.prototype; + var functionToString = uncurryThis$a(FunctionPrototype$1.toString); + var nameRE = /function\b(?:\s|\/\*[\S\s]*?\*\/|\/\/[^\n\r]*[\n\r]+)*([^\s(/]*)/; + var regExpExec = uncurryThis$a(nameRE.exec); + var NAME = 'name'; + + // Function instances `.name` property + // https://tc39.es/ecma262/#sec-function-instances-name + if (DESCRIPTORS$4 && !FUNCTION_NAME_EXISTS) { + defineBuiltInAccessor$1(FunctionPrototype$1, NAME, { + configurable: true, + get: function () { + try { + return regExpExec(nameRE, functionToString(this))[1]; + } catch (error) { + return ''; + } + } + }); + } + + var internalObjectKeys = objectKeysInternal; + var enumBugKeys$1 = enumBugKeys$3; + + // `Object.keys` method + // https://tc39.es/ecma262/#sec-object.keys + // eslint-disable-next-line es/no-object-keys -- safe + var objectKeys$2 = Object.keys || function keys(O) { + return internalObjectKeys(O, enumBugKeys$1); + }; + + var DESCRIPTORS$3 = descriptors; + var uncurryThis$9 = functionUncurryThis; + var call$9 = functionCall; + var fails$7 = fails$j; + var objectKeys$1 = objectKeys$2; + var getOwnPropertySymbolsModule = objectGetOwnPropertySymbols; + var propertyIsEnumerableModule = objectPropertyIsEnumerable; + var toObject$2 = toObject$5; + var IndexedObject$1 = indexedObject; + + // eslint-disable-next-line es/no-object-assign -- safe + var $assign = Object.assign; + // eslint-disable-next-line es/no-object-defineproperty -- required for testing + var defineProperty$4 = Object.defineProperty; + var concat = uncurryThis$9([].concat); + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + var objectAssign = !$assign || fails$7(function () { + // should have correct order of operations (Edge bug) + if (DESCRIPTORS$3 && $assign({ b: 1 }, $assign(defineProperty$4({}, 'a', { + enumerable: true, + get: function () { + defineProperty$4(this, 'b', { + value: 3, + enumerable: false + }); + } + }), { b: 2 })).b !== 1) return true; + // should work with symbols and should have deterministic property order (V8 bug) + var A = {}; + var B = {}; + // eslint-disable-next-line es/no-symbol -- safe + var symbol = Symbol('assign detection'); + var alphabet = 'abcdefghijklmnopqrst'; + A[symbol] = 7; + alphabet.split('').forEach(function (chr) { B[chr] = chr; }); + return $assign({}, A)[symbol] !== 7 || objectKeys$1($assign({}, B)).join('') !== alphabet; + }) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length` + var T = toObject$2(target); + var argumentsLength = arguments.length; + var index = 1; + var getOwnPropertySymbols = getOwnPropertySymbolsModule.f; + var propertyIsEnumerable = propertyIsEnumerableModule.f; + while (argumentsLength > index) { + var S = IndexedObject$1(arguments[index++]); + var keys = getOwnPropertySymbols ? concat(objectKeys$1(S), getOwnPropertySymbols(S)) : objectKeys$1(S); + var length = keys.length; + var j = 0; + var key; + while (length > j) { + key = keys[j++]; + if (!DESCRIPTORS$3 || call$9(propertyIsEnumerable, S, key)) T[key] = S[key]; + } + } return T; + } : $assign; + + var $$9 = _export; + var assign = objectAssign; + + // `Object.assign` method + // https://tc39.es/ecma262/#sec-object.assign + // eslint-disable-next-line es/no-object-assign -- required for testing + $$9({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, { + assign: assign + }); + + var TO_STRING_TAG_SUPPORT$1 = toStringTagSupport; + var classof$5 = classof$7; + + // `Object.prototype.toString` method implementation + // https://tc39.es/ecma262/#sec-object.prototype.tostring + var objectToString = TO_STRING_TAG_SUPPORT$1 ? {}.toString : function toString() { + return '[object ' + classof$5(this) + ']'; + }; + + var TO_STRING_TAG_SUPPORT = toStringTagSupport; + var defineBuiltIn$6 = defineBuiltIn$8; + var toString$3 = objectToString; + + // `Object.prototype.toString` method + // https://tc39.es/ecma262/#sec-object.prototype.tostring + if (!TO_STRING_TAG_SUPPORT) { + defineBuiltIn$6(Object.prototype, 'toString', toString$3, { unsafe: true }); + } + + var global$8 = global$j; + var classof$4 = classofRaw$2; + + var engineIsNode = classof$4(global$8.process) === 'process'; + + var uncurryThis$8 = functionUncurryThis; + var aCallable$6 = aCallable$8; + + var functionUncurryThisAccessor = function (object, key, method) { + try { + // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe + return uncurryThis$8(aCallable$6(Object.getOwnPropertyDescriptor(object, key)[method])); + } catch (error) { /* empty */ } + }; + + var isCallable$9 = isCallable$m; + + var $String$1 = String; + var $TypeError$6 = TypeError; + + var aPossiblePrototype$1 = function (argument) { + if (typeof argument == 'object' || isCallable$9(argument)) return argument; + throw new $TypeError$6("Can't set " + $String$1(argument) + ' as a prototype'); + }; + + /* eslint-disable no-proto -- safe */ + var uncurryThisAccessor = functionUncurryThisAccessor; + var anObject$8 = anObject$b; + var aPossiblePrototype = aPossiblePrototype$1; + + // `Object.setPrototypeOf` method + // https://tc39.es/ecma262/#sec-object.setprototypeof + // Works with __proto__ only. Old v8 can't work with null proto objects. + // eslint-disable-next-line es/no-object-setprototypeof -- safe + var objectSetPrototypeOf = Object.setPrototypeOf || ('__proto__' in {} ? function () { + var CORRECT_SETTER = false; + var test = {}; + var setter; + try { + setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set'); + setter(test, []); + CORRECT_SETTER = test instanceof Array; + } catch (error) { /* empty */ } + return function setPrototypeOf(O, proto) { + anObject$8(O); + aPossiblePrototype(proto); + if (CORRECT_SETTER) setter(O, proto); + else O.__proto__ = proto; + return O; + }; + }() : undefined); + + var defineProperty$3 = objectDefineProperty.f; + var hasOwn$4 = hasOwnProperty_1; + var wellKnownSymbol$a = wellKnownSymbol$h; + + var TO_STRING_TAG = wellKnownSymbol$a('toStringTag'); + + var setToStringTag$5 = function (target, TAG, STATIC) { + if (target && !STATIC) target = target.prototype; + if (target && !hasOwn$4(target, TO_STRING_TAG)) { + defineProperty$3(target, TO_STRING_TAG, { configurable: true, value: TAG }); + } + }; + + var getBuiltIn$3 = getBuiltIn$7; + var defineBuiltInAccessor = defineBuiltInAccessor$2; + var wellKnownSymbol$9 = wellKnownSymbol$h; + var DESCRIPTORS$2 = descriptors; + + var SPECIES$2 = wellKnownSymbol$9('species'); + + var setSpecies$1 = function (CONSTRUCTOR_NAME) { + var Constructor = getBuiltIn$3(CONSTRUCTOR_NAME); + + if (DESCRIPTORS$2 && Constructor && !Constructor[SPECIES$2]) { + defineBuiltInAccessor(Constructor, SPECIES$2, { + configurable: true, + get: function () { return this; } + }); + } + }; + + var isPrototypeOf$1 = objectIsPrototypeOf; + + var $TypeError$5 = TypeError; + + var anInstance$3 = function (it, Prototype) { + if (isPrototypeOf$1(Prototype, it)) return it; + throw new $TypeError$5('Incorrect invocation'); + }; + + var isConstructor = isConstructor$2; + var tryToString$2 = tryToString$4; + + var $TypeError$4 = TypeError; + + // `Assert: IsConstructor(argument) is true` + var aConstructor$1 = function (argument) { + if (isConstructor(argument)) return argument; + throw new $TypeError$4(tryToString$2(argument) + ' is not a constructor'); + }; + + var anObject$7 = anObject$b; + var aConstructor = aConstructor$1; + var isNullOrUndefined$3 = isNullOrUndefined$6; + var wellKnownSymbol$8 = wellKnownSymbol$h; + + var SPECIES$1 = wellKnownSymbol$8('species'); + + // `SpeciesConstructor` abstract operation + // https://tc39.es/ecma262/#sec-speciesconstructor + var speciesConstructor$1 = function (O, defaultConstructor) { + var C = anObject$7(O).constructor; + var S; + return C === undefined || isNullOrUndefined$3(S = anObject$7(C)[SPECIES$1]) ? defaultConstructor : aConstructor(S); + }; + + var NATIVE_BIND$1 = functionBindNative; + + var FunctionPrototype = Function.prototype; + var apply$1 = FunctionPrototype.apply; + var call$8 = FunctionPrototype.call; + + // eslint-disable-next-line es/no-reflect -- safe + var functionApply = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND$1 ? call$8.bind(apply$1) : function () { + return call$8.apply(apply$1, arguments); + }); + + var classofRaw = classofRaw$2; + var uncurryThis$7 = functionUncurryThis; + + var functionUncurryThisClause = function (fn) { + // Nashorn bug: + // https://github.com/zloirock/core-js/issues/1128 + // https://github.com/zloirock/core-js/issues/1130 + if (classofRaw(fn) === 'Function') return uncurryThis$7(fn); + }; + + var uncurryThis$6 = functionUncurryThisClause; + var aCallable$5 = aCallable$8; + var NATIVE_BIND = functionBindNative; + + var bind$5 = uncurryThis$6(uncurryThis$6.bind); + + // optional / simple context binding + var functionBindContext = function (fn, that) { + aCallable$5(fn); + return that === undefined ? fn : NATIVE_BIND ? bind$5(fn, that) : function (/* ...args */) { + return fn.apply(that, arguments); + }; + }; + + var getBuiltIn$2 = getBuiltIn$7; + + var html$2 = getBuiltIn$2('document', 'documentElement'); + + var uncurryThis$5 = functionUncurryThis; + + var arraySlice$2 = uncurryThis$5([].slice); + + var $TypeError$3 = TypeError; + + var validateArgumentsLength$1 = function (passed, required) { + if (passed < required) throw new $TypeError$3('Not enough arguments'); + return passed; + }; + + var userAgent$2 = engineUserAgent; + + // eslint-disable-next-line redos/no-vulnerable -- safe + var engineIsIos = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent$2); + + var global$7 = global$j; + var apply = functionApply; + var bind$4 = functionBindContext; + var isCallable$8 = isCallable$m; + var hasOwn$3 = hasOwnProperty_1; + var fails$6 = fails$j; + var html$1 = html$2; + var arraySlice$1 = arraySlice$2; + var createElement = documentCreateElement$2; + var validateArgumentsLength = validateArgumentsLength$1; + var IS_IOS$1 = engineIsIos; + var IS_NODE$3 = engineIsNode; + + var set = global$7.setImmediate; + var clear = global$7.clearImmediate; + var process$2 = global$7.process; + var Dispatch = global$7.Dispatch; + var Function$1 = global$7.Function; + var MessageChannel = global$7.MessageChannel; + var String$1 = global$7.String; + var counter = 0; + var queue$2 = {}; + var ONREADYSTATECHANGE = 'onreadystatechange'; + var $location, defer, channel, port; + + fails$6(function () { + // Deno throws a ReferenceError on `location` access without `--location` flag + $location = global$7.location; + }); + + var run = function (id) { + if (hasOwn$3(queue$2, id)) { + var fn = queue$2[id]; + delete queue$2[id]; + fn(); + } + }; + + var runner = function (id) { + return function () { + run(id); + }; + }; + + var eventListener = function (event) { + run(event.data); + }; + + var globalPostMessageDefer = function (id) { + // old engines have not location.origin + global$7.postMessage(String$1(id), $location.protocol + '//' + $location.host); + }; + + // Node.js 0.9+ & IE10+ has setImmediate, otherwise: + if (!set || !clear) { + set = function setImmediate(handler) { + validateArgumentsLength(arguments.length, 1); + var fn = isCallable$8(handler) ? handler : Function$1(handler); + var args = arraySlice$1(arguments, 1); + queue$2[++counter] = function () { + apply(fn, undefined, args); + }; + defer(counter); + return counter; + }; + clear = function clearImmediate(id) { + delete queue$2[id]; + }; + // Node.js 0.8- + if (IS_NODE$3) { + defer = function (id) { + process$2.nextTick(runner(id)); + }; + // Sphere (JS game engine) Dispatch API + } else if (Dispatch && Dispatch.now) { + defer = function (id) { + Dispatch.now(runner(id)); + }; + // Browsers with MessageChannel, includes WebWorkers + // except iOS - https://github.com/zloirock/core-js/issues/624 + } else if (MessageChannel && !IS_IOS$1) { + channel = new MessageChannel(); + port = channel.port2; + channel.port1.onmessage = eventListener; + defer = bind$4(port.postMessage, port); + // Browsers with postMessage, skip WebWorkers + // IE8 has postMessage, but it's sync & typeof its postMessage is 'object' + } else if ( + global$7.addEventListener && + isCallable$8(global$7.postMessage) && + !global$7.importScripts && + $location && $location.protocol !== 'file:' && + !fails$6(globalPostMessageDefer) + ) { + defer = globalPostMessageDefer; + global$7.addEventListener('message', eventListener, false); + // IE8- + } else if (ONREADYSTATECHANGE in createElement('script')) { + defer = function (id) { + html$1.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () { + html$1.removeChild(this); + run(id); + }; + }; + // Rest old browsers + } else { + defer = function (id) { + setTimeout(runner(id), 0); + }; + } + } + + var task$1 = { + set: set, + clear: clear + }; + + var Queue$2 = function () { + this.head = null; + this.tail = null; + }; + + Queue$2.prototype = { + add: function (item) { + var entry = { item: item, next: null }; + var tail = this.tail; + if (tail) tail.next = entry; + else this.head = entry; + this.tail = entry; + }, + get: function () { + var entry = this.head; + if (entry) { + var next = this.head = entry.next; + if (next === null) this.tail = null; + return entry.item; + } + } + }; + + var queue$1 = Queue$2; + + var userAgent$1 = engineUserAgent; + + var engineIsIosPebble = /ipad|iphone|ipod/i.test(userAgent$1) && typeof Pebble != 'undefined'; + + var userAgent = engineUserAgent; + + var engineIsWebosWebkit = /web0s(?!.*chrome)/i.test(userAgent); + + var global$6 = global$j; + var bind$3 = functionBindContext; + var getOwnPropertyDescriptor = objectGetOwnPropertyDescriptor.f; + var macrotask = task$1.set; + var Queue$1 = queue$1; + var IS_IOS = engineIsIos; + var IS_IOS_PEBBLE = engineIsIosPebble; + var IS_WEBOS_WEBKIT = engineIsWebosWebkit; + var IS_NODE$2 = engineIsNode; + + var MutationObserver = global$6.MutationObserver || global$6.WebKitMutationObserver; + var document$2 = global$6.document; + var process$1 = global$6.process; + var Promise$1 = global$6.Promise; + // Node.js 11 shows ExperimentalWarning on getting `queueMicrotask` + var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global$6, 'queueMicrotask'); + var microtask$1 = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value; + var notify$1, toggle, node, promise, then; + + // modern engines have queueMicrotask method + if (!microtask$1) { + var queue = new Queue$1(); + + var flush = function () { + var parent, fn; + if (IS_NODE$2 && (parent = process$1.domain)) parent.exit(); + while (fn = queue.get()) try { + fn(); + } catch (error) { + if (queue.head) notify$1(); + throw error; + } + if (parent) parent.enter(); + }; + + // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339 + // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898 + if (!IS_IOS && !IS_NODE$2 && !IS_WEBOS_WEBKIT && MutationObserver && document$2) { + toggle = true; + node = document$2.createTextNode(''); + new MutationObserver(flush).observe(node, { characterData: true }); + notify$1 = function () { + node.data = toggle = !toggle; + }; + // environments with maybe non-completely correct, but existent Promise + } else if (!IS_IOS_PEBBLE && Promise$1 && Promise$1.resolve) { + // Promise.resolve without an argument throws an error in LG WebOS 2 + promise = Promise$1.resolve(undefined); + // workaround of WebKit ~ iOS Safari 10.1 bug + promise.constructor = Promise$1; + then = bind$3(promise.then, promise); + notify$1 = function () { + then(flush); + }; + // Node.js without promises + } else if (IS_NODE$2) { + notify$1 = function () { + process$1.nextTick(flush); + }; + // for other environments - macrotask based on: + // - setImmediate + // - MessageChannel + // - window.postMessage + // - onreadystatechange + // - setTimeout + } else { + // `webpack` dev server bug on IE global methods - use bind(fn, global) + macrotask = bind$3(macrotask, global$6); + notify$1 = function () { + macrotask(flush); + }; + } + + microtask$1 = function (fn) { + if (!queue.head) notify$1(); + queue.add(fn); + }; + } + + var microtask_1 = microtask$1; + + var hostReportErrors$1 = function (a, b) { + try { + // eslint-disable-next-line no-console -- safe + arguments.length === 1 ? console.error(a) : console.error(a, b); + } catch (error) { /* empty */ } + }; + + var perform$3 = function (exec) { + try { + return { error: false, value: exec() }; + } catch (error) { + return { error: true, value: error }; + } + }; + + var global$5 = global$j; + + var promiseNativeConstructor = global$5.Promise; + + /* global Deno -- Deno case */ + var engineIsDeno = typeof Deno == 'object' && Deno && typeof Deno.version == 'object'; + + var IS_DENO$1 = engineIsDeno; + var IS_NODE$1 = engineIsNode; + + var engineIsBrowser = !IS_DENO$1 && !IS_NODE$1 + && typeof window == 'object' + && typeof document == 'object'; + + var global$4 = global$j; + var NativePromiseConstructor$3 = promiseNativeConstructor; + var isCallable$7 = isCallable$m; + var isForced$1 = isForced_1; + var inspectSource = inspectSource$3; + var wellKnownSymbol$7 = wellKnownSymbol$h; + var IS_BROWSER = engineIsBrowser; + var IS_DENO = engineIsDeno; + var V8_VERSION = engineV8Version; + + NativePromiseConstructor$3 && NativePromiseConstructor$3.prototype; + var SPECIES = wellKnownSymbol$7('species'); + var SUBCLASSING = false; + var NATIVE_PROMISE_REJECTION_EVENT$1 = isCallable$7(global$4.PromiseRejectionEvent); + + var FORCED_PROMISE_CONSTRUCTOR$5 = isForced$1('Promise', function () { + var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor$3); + var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor$3); + // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables + // https://bugs.chromium.org/p/chromium/issues/detail?id=830565 + // We can't detect it synchronously, so just check versions + if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true; + // We can't use @@species feature detection in V8 since it causes + // deoptimization and performance degradation + // https://github.com/zloirock/core-js/issues/679 + if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) { + // Detect correctness of subclassing with @@species support + var promise = new NativePromiseConstructor$3(function (resolve) { resolve(1); }); + var FakePromise = function (exec) { + exec(function () { /* empty */ }, function () { /* empty */ }); + }; + var constructor = promise.constructor = {}; + constructor[SPECIES] = FakePromise; + SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise; + if (!SUBCLASSING) return true; + // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test + } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT$1; + }); + + var promiseConstructorDetection = { + CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR$5, + REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT$1, + SUBCLASSING: SUBCLASSING + }; + + var newPromiseCapability$2 = {}; + + var aCallable$4 = aCallable$8; + + var $TypeError$2 = TypeError; + + var PromiseCapability = function (C) { + var resolve, reject; + this.promise = new C(function ($$resolve, $$reject) { + if (resolve !== undefined || reject !== undefined) throw new $TypeError$2('Bad Promise constructor'); + resolve = $$resolve; + reject = $$reject; + }); + this.resolve = aCallable$4(resolve); + this.reject = aCallable$4(reject); + }; + + // `NewPromiseCapability` abstract operation + // https://tc39.es/ecma262/#sec-newpromisecapability + newPromiseCapability$2.f = function (C) { + return new PromiseCapability(C); + }; + + var $$8 = _export; + var IS_NODE = engineIsNode; + var global$3 = global$j; + var call$7 = functionCall; + var defineBuiltIn$5 = defineBuiltIn$8; + var setPrototypeOf$2 = objectSetPrototypeOf; + var setToStringTag$4 = setToStringTag$5; + var setSpecies = setSpecies$1; + var aCallable$3 = aCallable$8; + var isCallable$6 = isCallable$m; + var isObject$7 = isObject$f; + var anInstance$2 = anInstance$3; + var speciesConstructor = speciesConstructor$1; + var task = task$1.set; + var microtask = microtask_1; + var hostReportErrors = hostReportErrors$1; + var perform$2 = perform$3; + var Queue = queue$1; + var InternalStateModule$3 = internalState; + var NativePromiseConstructor$2 = promiseNativeConstructor; + var PromiseConstructorDetection = promiseConstructorDetection; + var newPromiseCapabilityModule$3 = newPromiseCapability$2; + + var PROMISE = 'Promise'; + var FORCED_PROMISE_CONSTRUCTOR$4 = PromiseConstructorDetection.CONSTRUCTOR; + var NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT; + var NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING; + var getInternalPromiseState = InternalStateModule$3.getterFor(PROMISE); + var setInternalState$3 = InternalStateModule$3.set; + var NativePromisePrototype$1 = NativePromiseConstructor$2 && NativePromiseConstructor$2.prototype; + var PromiseConstructor = NativePromiseConstructor$2; + var PromisePrototype = NativePromisePrototype$1; + var TypeError$1 = global$3.TypeError; + var document$1 = global$3.document; + var process = global$3.process; + var newPromiseCapability$1 = newPromiseCapabilityModule$3.f; + var newGenericPromiseCapability = newPromiseCapability$1; + + var DISPATCH_EVENT = !!(document$1 && document$1.createEvent && global$3.dispatchEvent); + var UNHANDLED_REJECTION = 'unhandledrejection'; + var REJECTION_HANDLED = 'rejectionhandled'; + var PENDING = 0; + var FULFILLED = 1; + var REJECTED = 2; + var HANDLED = 1; + var UNHANDLED = 2; + + var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen; + + // helpers + var isThenable = function (it) { + var then; + return isObject$7(it) && isCallable$6(then = it.then) ? then : false; + }; + + var callReaction = function (reaction, state) { + var value = state.value; + var ok = state.state === FULFILLED; + var handler = ok ? reaction.ok : reaction.fail; + var resolve = reaction.resolve; + var reject = reaction.reject; + var domain = reaction.domain; + var result, then, exited; + try { + if (handler) { + if (!ok) { + if (state.rejection === UNHANDLED) onHandleUnhandled(state); + state.rejection = HANDLED; + } + if (handler === true) result = value; + else { + if (domain) domain.enter(); + result = handler(value); // can throw + if (domain) { + domain.exit(); + exited = true; + } + } + if (result === reaction.promise) { + reject(new TypeError$1('Promise-chain cycle')); + } else if (then = isThenable(result)) { + call$7(then, result, resolve, reject); + } else resolve(result); + } else reject(value); + } catch (error) { + if (domain && !exited) domain.exit(); + reject(error); + } + }; + + var notify = function (state, isReject) { + if (state.notified) return; + state.notified = true; + microtask(function () { + var reactions = state.reactions; + var reaction; + while (reaction = reactions.get()) { + callReaction(reaction, state); + } + state.notified = false; + if (isReject && !state.rejection) onUnhandled(state); + }); + }; + + var dispatchEvent = function (name, promise, reason) { + var event, handler; + if (DISPATCH_EVENT) { + event = document$1.createEvent('Event'); + event.promise = promise; + event.reason = reason; + event.initEvent(name, false, true); + global$3.dispatchEvent(event); + } else event = { promise: promise, reason: reason }; + if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global$3['on' + name])) handler(event); + else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason); + }; + + var onUnhandled = function (state) { + call$7(task, global$3, function () { + var promise = state.facade; + var value = state.value; + var IS_UNHANDLED = isUnhandled(state); + var result; + if (IS_UNHANDLED) { + result = perform$2(function () { + if (IS_NODE) { + process.emit('unhandledRejection', value, promise); + } else dispatchEvent(UNHANDLED_REJECTION, promise, value); + }); + // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should + state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED; + if (result.error) throw result.value; + } + }); + }; + + var isUnhandled = function (state) { + return state.rejection !== HANDLED && !state.parent; + }; + + var onHandleUnhandled = function (state) { + call$7(task, global$3, function () { + var promise = state.facade; + if (IS_NODE) { + process.emit('rejectionHandled', promise); + } else dispatchEvent(REJECTION_HANDLED, promise, state.value); + }); + }; + + var bind$2 = function (fn, state, unwrap) { + return function (value) { + fn(state, value, unwrap); + }; + }; + + var internalReject = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + state.value = value; + state.state = REJECTED; + notify(state, true); + }; + + var internalResolve = function (state, value, unwrap) { + if (state.done) return; + state.done = true; + if (unwrap) state = unwrap; + try { + if (state.facade === value) throw new TypeError$1("Promise can't be resolved itself"); + var then = isThenable(value); + if (then) { + microtask(function () { + var wrapper = { done: false }; + try { + call$7(then, value, + bind$2(internalResolve, wrapper, state), + bind$2(internalReject, wrapper, state) + ); + } catch (error) { + internalReject(wrapper, error, state); + } + }); + } else { + state.value = value; + state.state = FULFILLED; + notify(state, false); + } + } catch (error) { + internalReject({ done: false }, error, state); + } + }; + + // constructor polyfill + if (FORCED_PROMISE_CONSTRUCTOR$4) { + // 25.4.3.1 Promise(executor) + PromiseConstructor = function Promise(executor) { + anInstance$2(this, PromisePrototype); + aCallable$3(executor); + call$7(Internal, this); + var state = getInternalPromiseState(this); + try { + executor(bind$2(internalResolve, state), bind$2(internalReject, state)); + } catch (error) { + internalReject(state, error); + } + }; + + PromisePrototype = PromiseConstructor.prototype; + + // eslint-disable-next-line no-unused-vars -- required for `.length` + Internal = function Promise(executor) { + setInternalState$3(this, { + type: PROMISE, + done: false, + notified: false, + parent: false, + reactions: new Queue(), + rejection: false, + state: PENDING, + value: undefined + }); + }; + + // `Promise.prototype.then` method + // https://tc39.es/ecma262/#sec-promise.prototype.then + Internal.prototype = defineBuiltIn$5(PromisePrototype, 'then', function then(onFulfilled, onRejected) { + var state = getInternalPromiseState(this); + var reaction = newPromiseCapability$1(speciesConstructor(this, PromiseConstructor)); + state.parent = true; + reaction.ok = isCallable$6(onFulfilled) ? onFulfilled : true; + reaction.fail = isCallable$6(onRejected) && onRejected; + reaction.domain = IS_NODE ? process.domain : undefined; + if (state.state === PENDING) state.reactions.add(reaction); + else microtask(function () { + callReaction(reaction, state); + }); + return reaction.promise; + }); + + OwnPromiseCapability = function () { + var promise = new Internal(); + var state = getInternalPromiseState(promise); + this.promise = promise; + this.resolve = bind$2(internalResolve, state); + this.reject = bind$2(internalReject, state); + }; + + newPromiseCapabilityModule$3.f = newPromiseCapability$1 = function (C) { + return C === PromiseConstructor || C === PromiseWrapper + ? new OwnPromiseCapability(C) + : newGenericPromiseCapability(C); + }; + + if (isCallable$6(NativePromiseConstructor$2) && NativePromisePrototype$1 !== Object.prototype) { + nativeThen = NativePromisePrototype$1.then; + + if (!NATIVE_PROMISE_SUBCLASSING) { + // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs + defineBuiltIn$5(NativePromisePrototype$1, 'then', function then(onFulfilled, onRejected) { + var that = this; + return new PromiseConstructor(function (resolve, reject) { + call$7(nativeThen, that, resolve, reject); + }).then(onFulfilled, onRejected); + // https://github.com/zloirock/core-js/issues/640 + }, { unsafe: true }); + } + + // make `.constructor === Promise` work for native promise-based APIs + try { + delete NativePromisePrototype$1.constructor; + } catch (error) { /* empty */ } + + // make `instanceof Promise` work for native promise-based APIs + if (setPrototypeOf$2) { + setPrototypeOf$2(NativePromisePrototype$1, PromisePrototype); + } + } + } + + $$8({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR$4 }, { + Promise: PromiseConstructor + }); + + setToStringTag$4(PromiseConstructor, PROMISE, false); + setSpecies(PROMISE); + + var iterators = {}; + + var wellKnownSymbol$6 = wellKnownSymbol$h; + var Iterators$4 = iterators; + + var ITERATOR$5 = wellKnownSymbol$6('iterator'); + var ArrayPrototype$1 = Array.prototype; + + // check on default Array iterator + var isArrayIteratorMethod$1 = function (it) { + return it !== undefined && (Iterators$4.Array === it || ArrayPrototype$1[ITERATOR$5] === it); + }; + + var classof$3 = classof$7; + var getMethod$1 = getMethod$3; + var isNullOrUndefined$2 = isNullOrUndefined$6; + var Iterators$3 = iterators; + var wellKnownSymbol$5 = wellKnownSymbol$h; + + var ITERATOR$4 = wellKnownSymbol$5('iterator'); + + var getIteratorMethod$2 = function (it) { + if (!isNullOrUndefined$2(it)) return getMethod$1(it, ITERATOR$4) + || getMethod$1(it, '@@iterator') + || Iterators$3[classof$3(it)]; + }; + + var call$6 = functionCall; + var aCallable$2 = aCallable$8; + var anObject$6 = anObject$b; + var tryToString$1 = tryToString$4; + var getIteratorMethod$1 = getIteratorMethod$2; + + var $TypeError$1 = TypeError; + + var getIterator$1 = function (argument, usingIterator) { + var iteratorMethod = arguments.length < 2 ? getIteratorMethod$1(argument) : usingIterator; + if (aCallable$2(iteratorMethod)) return anObject$6(call$6(iteratorMethod, argument)); + throw new $TypeError$1(tryToString$1(argument) + ' is not iterable'); + }; + + var call$5 = functionCall; + var anObject$5 = anObject$b; + var getMethod = getMethod$3; + + var iteratorClose$1 = function (iterator, kind, value) { + var innerResult, innerError; + anObject$5(iterator); + try { + innerResult = getMethod(iterator, 'return'); + if (!innerResult) { + if (kind === 'throw') throw value; + return value; + } + innerResult = call$5(innerResult, iterator); + } catch (error) { + innerError = true; + innerResult = error; + } + if (kind === 'throw') throw value; + if (innerError) throw innerResult; + anObject$5(innerResult); + return value; + }; + + var bind$1 = functionBindContext; + var call$4 = functionCall; + var anObject$4 = anObject$b; + var tryToString = tryToString$4; + var isArrayIteratorMethod = isArrayIteratorMethod$1; + var lengthOfArrayLike$2 = lengthOfArrayLike$5; + var isPrototypeOf = objectIsPrototypeOf; + var getIterator = getIterator$1; + var getIteratorMethod = getIteratorMethod$2; + var iteratorClose = iteratorClose$1; + + var $TypeError = TypeError; + + var Result = function (stopped, result) { + this.stopped = stopped; + this.result = result; + }; + + var ResultPrototype = Result.prototype; + + var iterate$4 = function (iterable, unboundFunction, options) { + var that = options && options.that; + var AS_ENTRIES = !!(options && options.AS_ENTRIES); + var IS_RECORD = !!(options && options.IS_RECORD); + var IS_ITERATOR = !!(options && options.IS_ITERATOR); + var INTERRUPTED = !!(options && options.INTERRUPTED); + var fn = bind$1(unboundFunction, that); + var iterator, iterFn, index, length, result, next, step; + + var stop = function (condition) { + if (iterator) iteratorClose(iterator, 'normal', condition); + return new Result(true, condition); + }; + + var callFn = function (value) { + if (AS_ENTRIES) { + anObject$4(value); + return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]); + } return INTERRUPTED ? fn(value, stop) : fn(value); + }; + + if (IS_RECORD) { + iterator = iterable.iterator; + } else if (IS_ITERATOR) { + iterator = iterable; + } else { + iterFn = getIteratorMethod(iterable); + if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable'); + // optimisation for array iterators + if (isArrayIteratorMethod(iterFn)) { + for (index = 0, length = lengthOfArrayLike$2(iterable); length > index; index++) { + result = callFn(iterable[index]); + if (result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + } + iterator = getIterator(iterable, iterFn); + } + + next = IS_RECORD ? iterable.next : iterator.next; + while (!(step = call$4(next, iterator)).done) { + try { + result = callFn(step.value); + } catch (error) { + iteratorClose(iterator, 'throw', error); + } + if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result; + } return new Result(false); + }; + + var wellKnownSymbol$4 = wellKnownSymbol$h; + + var ITERATOR$3 = wellKnownSymbol$4('iterator'); + var SAFE_CLOSING = false; + + try { + var called = 0; + var iteratorWithReturn = { + next: function () { + return { done: !!called++ }; + }, + 'return': function () { + SAFE_CLOSING = true; + } + }; + iteratorWithReturn[ITERATOR$3] = function () { + return this; + }; + // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing + Array.from(iteratorWithReturn, function () { throw 2; }); + } catch (error) { /* empty */ } + + var checkCorrectnessOfIteration$2 = function (exec, SKIP_CLOSING) { + try { + if (!SKIP_CLOSING && !SAFE_CLOSING) return false; + } catch (error) { return false; } // workaround of old WebKit + `eval` bug + var ITERATION_SUPPORT = false; + try { + var object = {}; + object[ITERATOR$3] = function () { + return { + next: function () { + return { done: ITERATION_SUPPORT = true }; + } + }; + }; + exec(object); + } catch (error) { /* empty */ } + return ITERATION_SUPPORT; + }; + + var NativePromiseConstructor$1 = promiseNativeConstructor; + var checkCorrectnessOfIteration$1 = checkCorrectnessOfIteration$2; + var FORCED_PROMISE_CONSTRUCTOR$3 = promiseConstructorDetection.CONSTRUCTOR; + + var promiseStaticsIncorrectIteration = FORCED_PROMISE_CONSTRUCTOR$3 || !checkCorrectnessOfIteration$1(function (iterable) { + NativePromiseConstructor$1.all(iterable).then(undefined, function () { /* empty */ }); + }); + + var $$7 = _export; + var call$3 = functionCall; + var aCallable$1 = aCallable$8; + var newPromiseCapabilityModule$2 = newPromiseCapability$2; + var perform$1 = perform$3; + var iterate$3 = iterate$4; + var PROMISE_STATICS_INCORRECT_ITERATION$1 = promiseStaticsIncorrectIteration; + + // `Promise.all` method + // https://tc39.es/ecma262/#sec-promise.all + $$7({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION$1 }, { + all: function all(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$2.f(C); + var resolve = capability.resolve; + var reject = capability.reject; + var result = perform$1(function () { + var $promiseResolve = aCallable$1(C.resolve); + var values = []; + var counter = 0; + var remaining = 1; + iterate$3(iterable, function (promise) { + var index = counter++; + var alreadyCalled = false; + remaining++; + call$3($promiseResolve, C, promise).then(function (value) { + if (alreadyCalled) return; + alreadyCalled = true; + values[index] = value; + --remaining || resolve(values); + }, reject); + }); + --remaining || resolve(values); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var $$6 = _export; + var FORCED_PROMISE_CONSTRUCTOR$2 = promiseConstructorDetection.CONSTRUCTOR; + var NativePromiseConstructor = promiseNativeConstructor; + var getBuiltIn$1 = getBuiltIn$7; + var isCallable$5 = isCallable$m; + var defineBuiltIn$4 = defineBuiltIn$8; + + var NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype; + + // `Promise.prototype.catch` method + // https://tc39.es/ecma262/#sec-promise.prototype.catch + $$6({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR$2, real: true }, { + 'catch': function (onRejected) { + return this.then(undefined, onRejected); + } + }); + + // makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then` + if (isCallable$5(NativePromiseConstructor)) { + var method = getBuiltIn$1('Promise').prototype['catch']; + if (NativePromisePrototype['catch'] !== method) { + defineBuiltIn$4(NativePromisePrototype, 'catch', method, { unsafe: true }); + } + } + + var $$5 = _export; + var call$2 = functionCall; + var aCallable = aCallable$8; + var newPromiseCapabilityModule$1 = newPromiseCapability$2; + var perform = perform$3; + var iterate$2 = iterate$4; + var PROMISE_STATICS_INCORRECT_ITERATION = promiseStaticsIncorrectIteration; + + // `Promise.race` method + // https://tc39.es/ecma262/#sec-promise.race + $$5({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, { + race: function race(iterable) { + var C = this; + var capability = newPromiseCapabilityModule$1.f(C); + var reject = capability.reject; + var result = perform(function () { + var $promiseResolve = aCallable(C.resolve); + iterate$2(iterable, function (promise) { + call$2($promiseResolve, C, promise).then(capability.resolve, reject); + }); + }); + if (result.error) reject(result.value); + return capability.promise; + } + }); + + var $$4 = _export; + var call$1 = functionCall; + var newPromiseCapabilityModule = newPromiseCapability$2; + var FORCED_PROMISE_CONSTRUCTOR$1 = promiseConstructorDetection.CONSTRUCTOR; + + // `Promise.reject` method + // https://tc39.es/ecma262/#sec-promise.reject + $$4({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR$1 }, { + reject: function reject(r) { + var capability = newPromiseCapabilityModule.f(this); + call$1(capability.reject, undefined, r); + return capability.promise; + } + }); + + var anObject$3 = anObject$b; + var isObject$6 = isObject$f; + var newPromiseCapability = newPromiseCapability$2; + + var promiseResolve$1 = function (C, x) { + anObject$3(C); + if (isObject$6(x) && x.constructor === C) return x; + var promiseCapability = newPromiseCapability.f(C); + var resolve = promiseCapability.resolve; + resolve(x); + return promiseCapability.promise; + }; + + var $$3 = _export; + var getBuiltIn = getBuiltIn$7; + var FORCED_PROMISE_CONSTRUCTOR = promiseConstructorDetection.CONSTRUCTOR; + var promiseResolve = promiseResolve$1; + + getBuiltIn('Promise'); + + // `Promise.resolve` method + // https://tc39.es/ecma262/#sec-promise.resolve + $$3({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, { + resolve: function resolve(x) { + return promiseResolve(this, x); + } + }); + + var objectDefineProperties = {}; + + var DESCRIPTORS$1 = descriptors; + var V8_PROTOTYPE_DEFINE_BUG = v8PrototypeDefineBug; + var definePropertyModule = objectDefineProperty; + var anObject$2 = anObject$b; + var toIndexedObject$2 = toIndexedObject$6; + var objectKeys = objectKeys$2; + + // `Object.defineProperties` method + // https://tc39.es/ecma262/#sec-object.defineproperties + // eslint-disable-next-line es/no-object-defineproperties -- safe + objectDefineProperties.f = DESCRIPTORS$1 && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) { + anObject$2(O); + var props = toIndexedObject$2(Properties); + var keys = objectKeys(Properties); + var length = keys.length; + var index = 0; + var key; + while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]); + return O; + }; + + /* global ActiveXObject -- old IE, WSH */ + var anObject$1 = anObject$b; + var definePropertiesModule = objectDefineProperties; + var enumBugKeys = enumBugKeys$3; + var hiddenKeys$1 = hiddenKeys$5; + var html = html$2; + var documentCreateElement$1 = documentCreateElement$2; + var sharedKey$1 = sharedKey$3; + + var GT = '>'; + var LT = '<'; + var PROTOTYPE = 'prototype'; + var SCRIPT = 'script'; + var IE_PROTO$1 = sharedKey$1('IE_PROTO'); + + var EmptyConstructor = function () { /* empty */ }; + + var scriptTag = function (content) { + return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT; + }; + + // Create object with fake `null` prototype: use ActiveX Object with cleared prototype + var NullProtoObjectViaActiveX = function (activeXDocument) { + activeXDocument.write(scriptTag('')); + activeXDocument.close(); + var temp = activeXDocument.parentWindow.Object; + activeXDocument = null; // avoid memory leak + return temp; + }; + + // Create object with fake `null` prototype: use iframe Object with cleared prototype + var NullProtoObjectViaIFrame = function () { + // Thrash, waste and sodomy: IE GC bug + var iframe = documentCreateElement$1('iframe'); + var JS = 'java' + SCRIPT + ':'; + var iframeDocument; + iframe.style.display = 'none'; + html.appendChild(iframe); + // https://github.com/zloirock/core-js/issues/475 + iframe.src = String(JS); + iframeDocument = iframe.contentWindow.document; + iframeDocument.open(); + iframeDocument.write(scriptTag('document.F=Object')); + iframeDocument.close(); + return iframeDocument.F; + }; + + // Check for document.domain and active x support + // No need to use active x approach when document.domain is not set + // see https://github.com/es-shims/es5-shim/issues/150 + // variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346 + // avoid IE GC bug + var activeXDocument; + var NullProtoObject = function () { + try { + activeXDocument = new ActiveXObject('htmlfile'); + } catch (error) { /* ignore */ } + NullProtoObject = typeof document != 'undefined' + ? document.domain && activeXDocument + ? NullProtoObjectViaActiveX(activeXDocument) // old IE + : NullProtoObjectViaIFrame() + : NullProtoObjectViaActiveX(activeXDocument); // WSH + var length = enumBugKeys.length; + while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]]; + return NullProtoObject(); + }; + + hiddenKeys$1[IE_PROTO$1] = true; + + // `Object.create` method + // https://tc39.es/ecma262/#sec-object.create + // eslint-disable-next-line es/no-object-create -- safe + var objectCreate = Object.create || function create(O, Properties) { + var result; + if (O !== null) { + EmptyConstructor[PROTOTYPE] = anObject$1(O); + result = new EmptyConstructor(); + EmptyConstructor[PROTOTYPE] = null; + // add "__proto__" for Object.getPrototypeOf polyfill + result[IE_PROTO$1] = O; + } else result = NullProtoObject(); + return Properties === undefined ? result : definePropertiesModule.f(result, Properties); + }; + + var wellKnownSymbol$3 = wellKnownSymbol$h; + var create$1 = objectCreate; + var defineProperty$2 = objectDefineProperty.f; + + var UNSCOPABLES = wellKnownSymbol$3('unscopables'); + var ArrayPrototype = Array.prototype; + + // Array.prototype[@@unscopables] + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + if (ArrayPrototype[UNSCOPABLES] === undefined) { + defineProperty$2(ArrayPrototype, UNSCOPABLES, { + configurable: true, + value: create$1(null) + }); + } + + // add a key to Array.prototype[@@unscopables] + var addToUnscopables$1 = function (key) { + ArrayPrototype[UNSCOPABLES][key] = true; + }; + + var fails$5 = fails$j; + + var correctPrototypeGetter = !fails$5(function () { + function F() { /* empty */ } + F.prototype.constructor = null; + // eslint-disable-next-line es/no-object-getprototypeof -- required for testing + return Object.getPrototypeOf(new F()) !== F.prototype; + }); + + var hasOwn$2 = hasOwnProperty_1; + var isCallable$4 = isCallable$m; + var toObject$1 = toObject$5; + var sharedKey = sharedKey$3; + var CORRECT_PROTOTYPE_GETTER = correctPrototypeGetter; + + var IE_PROTO = sharedKey('IE_PROTO'); + var $Object = Object; + var ObjectPrototype = $Object.prototype; + + // `Object.getPrototypeOf` method + // https://tc39.es/ecma262/#sec-object.getprototypeof + // eslint-disable-next-line es/no-object-getprototypeof -- safe + var objectGetPrototypeOf = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) { + var object = toObject$1(O); + if (hasOwn$2(object, IE_PROTO)) return object[IE_PROTO]; + var constructor = object.constructor; + if (isCallable$4(constructor) && object instanceof constructor) { + return constructor.prototype; + } return object instanceof $Object ? ObjectPrototype : null; + }; + + var fails$4 = fails$j; + var isCallable$3 = isCallable$m; + var isObject$5 = isObject$f; + var getPrototypeOf$1 = objectGetPrototypeOf; + var defineBuiltIn$3 = defineBuiltIn$8; + var wellKnownSymbol$2 = wellKnownSymbol$h; + + var ITERATOR$2 = wellKnownSymbol$2('iterator'); + var BUGGY_SAFARI_ITERATORS$1 = false; + + // `%IteratorPrototype%` object + // https://tc39.es/ecma262/#sec-%iteratorprototype%-object + var IteratorPrototype$2, PrototypeOfArrayIteratorPrototype, arrayIterator; + + /* eslint-disable es/no-array-prototype-keys -- safe */ + if ([].keys) { + arrayIterator = [].keys(); + // Safari 8 has buggy iterators w/o `next` + if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS$1 = true; + else { + PrototypeOfArrayIteratorPrototype = getPrototypeOf$1(getPrototypeOf$1(arrayIterator)); + if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype$2 = PrototypeOfArrayIteratorPrototype; + } + } + + var NEW_ITERATOR_PROTOTYPE = !isObject$5(IteratorPrototype$2) || fails$4(function () { + var test = {}; + // FF44- legacy iterators case + return IteratorPrototype$2[ITERATOR$2].call(test) !== test; + }); + + if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype$2 = {}; + + // `%IteratorPrototype%[@@iterator]()` method + // https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator + if (!isCallable$3(IteratorPrototype$2[ITERATOR$2])) { + defineBuiltIn$3(IteratorPrototype$2, ITERATOR$2, function () { + return this; + }); + } + + var iteratorsCore = { + IteratorPrototype: IteratorPrototype$2, + BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS$1 + }; + + var IteratorPrototype$1 = iteratorsCore.IteratorPrototype; + var create = objectCreate; + var createPropertyDescriptor = createPropertyDescriptor$4; + var setToStringTag$3 = setToStringTag$5; + var Iterators$2 = iterators; + + var returnThis$1 = function () { return this; }; + + var iteratorCreateConstructor = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) { + var TO_STRING_TAG = NAME + ' Iterator'; + IteratorConstructor.prototype = create(IteratorPrototype$1, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) }); + setToStringTag$3(IteratorConstructor, TO_STRING_TAG, false); + Iterators$2[TO_STRING_TAG] = returnThis$1; + return IteratorConstructor; + }; + + var $$2 = _export; + var call = functionCall; + var FunctionName = functionName; + var isCallable$2 = isCallable$m; + var createIteratorConstructor = iteratorCreateConstructor; + var getPrototypeOf = objectGetPrototypeOf; + var setPrototypeOf$1 = objectSetPrototypeOf; + var setToStringTag$2 = setToStringTag$5; + var createNonEnumerableProperty$1 = createNonEnumerableProperty$4; + var defineBuiltIn$2 = defineBuiltIn$8; + var wellKnownSymbol$1 = wellKnownSymbol$h; + var Iterators$1 = iterators; + var IteratorsCore = iteratorsCore; + + var PROPER_FUNCTION_NAME = FunctionName.PROPER; + var CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE; + var IteratorPrototype = IteratorsCore.IteratorPrototype; + var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS; + var ITERATOR$1 = wellKnownSymbol$1('iterator'); + var KEYS = 'keys'; + var VALUES = 'values'; + var ENTRIES = 'entries'; + + var returnThis = function () { return this; }; + + var iteratorDefine = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) { + createIteratorConstructor(IteratorConstructor, NAME, next); + + var getIterationMethod = function (KIND) { + if (KIND === DEFAULT && defaultIterator) return defaultIterator; + if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND]; + + switch (KIND) { + case KEYS: return function keys() { return new IteratorConstructor(this, KIND); }; + case VALUES: return function values() { return new IteratorConstructor(this, KIND); }; + case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); }; + } + + return function () { return new IteratorConstructor(this); }; + }; + + var TO_STRING_TAG = NAME + ' Iterator'; + var INCORRECT_VALUES_NAME = false; + var IterablePrototype = Iterable.prototype; + var nativeIterator = IterablePrototype[ITERATOR$1] + || IterablePrototype['@@iterator'] + || DEFAULT && IterablePrototype[DEFAULT]; + var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT); + var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator; + var CurrentIteratorPrototype, methods, KEY; + + // fix native + if (anyNativeIterator) { + CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable())); + if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) { + if (getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) { + if (setPrototypeOf$1) { + setPrototypeOf$1(CurrentIteratorPrototype, IteratorPrototype); + } else if (!isCallable$2(CurrentIteratorPrototype[ITERATOR$1])) { + defineBuiltIn$2(CurrentIteratorPrototype, ITERATOR$1, returnThis); + } + } + // Set @@toStringTag to native iterators + setToStringTag$2(CurrentIteratorPrototype, TO_STRING_TAG, true); + } + } + + // fix Array.prototype.{ values, @@iterator }.name in V8 / FF + if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) { + if (CONFIGURABLE_FUNCTION_NAME) { + createNonEnumerableProperty$1(IterablePrototype, 'name', VALUES); + } else { + INCORRECT_VALUES_NAME = true; + defaultIterator = function values() { return call(nativeIterator, this); }; + } + } + + // export additional methods + if (DEFAULT) { + methods = { + values: getIterationMethod(VALUES), + keys: IS_SET ? defaultIterator : getIterationMethod(KEYS), + entries: getIterationMethod(ENTRIES) + }; + if (FORCED) for (KEY in methods) { + if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) { + defineBuiltIn$2(IterablePrototype, KEY, methods[KEY]); + } + } else $$2({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods); + } + + // define iterator + if (IterablePrototype[ITERATOR$1] !== defaultIterator) { + defineBuiltIn$2(IterablePrototype, ITERATOR$1, defaultIterator, { name: DEFAULT }); + } + Iterators$1[NAME] = defaultIterator; + + return methods; + }; + + // `CreateIterResultObject` abstract operation + // https://tc39.es/ecma262/#sec-createiterresultobject + var createIterResultObject$2 = function (value, done) { + return { value: value, done: done }; + }; + + var toIndexedObject$1 = toIndexedObject$6; + var addToUnscopables = addToUnscopables$1; + var Iterators = iterators; + var InternalStateModule$2 = internalState; + var defineProperty$1 = objectDefineProperty.f; + var defineIterator$1 = iteratorDefine; + var createIterResultObject$1 = createIterResultObject$2; + var DESCRIPTORS = descriptors; + + var ARRAY_ITERATOR = 'Array Iterator'; + var setInternalState$2 = InternalStateModule$2.set; + var getInternalState$1 = InternalStateModule$2.getterFor(ARRAY_ITERATOR); + + // `Array.prototype.entries` method + // https://tc39.es/ecma262/#sec-array.prototype.entries + // `Array.prototype.keys` method + // https://tc39.es/ecma262/#sec-array.prototype.keys + // `Array.prototype.values` method + // https://tc39.es/ecma262/#sec-array.prototype.values + // `Array.prototype[@@iterator]` method + // https://tc39.es/ecma262/#sec-array.prototype-@@iterator + // `CreateArrayIterator` internal method + // https://tc39.es/ecma262/#sec-createarrayiterator + var es_array_iterator = defineIterator$1(Array, 'Array', function (iterated, kind) { + setInternalState$2(this, { + type: ARRAY_ITERATOR, + target: toIndexedObject$1(iterated), // target + index: 0, // next index + kind: kind // kind + }); + // `%ArrayIteratorPrototype%.next` method + // https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next + }, function () { + var state = getInternalState$1(this); + var target = state.target; + var index = state.index++; + if (!target || index >= target.length) { + state.target = undefined; + return createIterResultObject$1(undefined, true); + } + switch (state.kind) { + case 'keys': return createIterResultObject$1(index, false); + case 'values': return createIterResultObject$1(target[index], false); + } return createIterResultObject$1([index, target[index]], false); + }, 'values'); + + // argumentsList[@@iterator] is %ArrayProto_values% + // https://tc39.es/ecma262/#sec-createunmappedargumentsobject + // https://tc39.es/ecma262/#sec-createmappedargumentsobject + var values = Iterators.Arguments = Iterators.Array; + + // https://tc39.es/ecma262/#sec-array.prototype-@@unscopables + addToUnscopables('keys'); + addToUnscopables('values'); + addToUnscopables('entries'); + + // V8 ~ Chrome 45- bug + if (DESCRIPTORS && values.name !== 'values') try { + defineProperty$1(values, 'name', { value: 'values' }); + } catch (error) { /* empty */ } + + var classof$2 = classof$7; + + var $String = String; + + var toString$2 = function (argument) { + if (classof$2(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string'); + return $String(argument); + }; + + var uncurryThis$4 = functionUncurryThis; + var toIntegerOrInfinity = toIntegerOrInfinity$3; + var toString$1 = toString$2; + var requireObjectCoercible = requireObjectCoercible$3; + + var charAt$1 = uncurryThis$4(''.charAt); + var charCodeAt = uncurryThis$4(''.charCodeAt); + var stringSlice = uncurryThis$4(''.slice); + + var createMethod$1 = function (CONVERT_TO_STRING) { + return function ($this, pos) { + var S = toString$1(requireObjectCoercible($this)); + var position = toIntegerOrInfinity(pos); + var size = S.length; + var first, second; + if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined; + first = charCodeAt(S, position); + return first < 0xD800 || first > 0xDBFF || position + 1 === size + || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF + ? CONVERT_TO_STRING + ? charAt$1(S, position) + : first + : CONVERT_TO_STRING + ? stringSlice(S, position, position + 2) + : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000; + }; + }; + + var stringMultibyte = { + // `String.prototype.codePointAt` method + // https://tc39.es/ecma262/#sec-string.prototype.codepointat + codeAt: createMethod$1(false), + // `String.prototype.at` method + // https://github.com/mathiasbynens/String.prototype.at + charAt: createMethod$1(true) + }; + + var charAt = stringMultibyte.charAt; + var toString = toString$2; + var InternalStateModule$1 = internalState; + var defineIterator = iteratorDefine; + var createIterResultObject = createIterResultObject$2; + + var STRING_ITERATOR = 'String Iterator'; + var setInternalState$1 = InternalStateModule$1.set; + var getInternalState = InternalStateModule$1.getterFor(STRING_ITERATOR); + + // `String.prototype[@@iterator]` method + // https://tc39.es/ecma262/#sec-string.prototype-@@iterator + defineIterator(String, 'String', function (iterated) { + setInternalState$1(this, { + type: STRING_ITERATOR, + string: toString(iterated), + index: 0 + }); + // `%StringIteratorPrototype%.next` method + // https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next + }, function next() { + var state = getInternalState(this); + var string = state.string; + var index = state.index; + var point; + if (index >= string.length) return createIterResultObject(undefined, true); + point = charAt(string, index); + state.index += point.length; + return createIterResultObject(point, false); + }); + + var internalMetadata = {exports: {}}; + + var objectGetOwnPropertyNamesExternal = {}; + + var toAbsoluteIndex = toAbsoluteIndex$2; + var lengthOfArrayLike$1 = lengthOfArrayLike$5; + var createProperty = createProperty$2; + + var $Array = Array; + var max = Math.max; + + var arraySliceSimple = function (O, start, end) { + var length = lengthOfArrayLike$1(O); + var k = toAbsoluteIndex(start, length); + var fin = toAbsoluteIndex(end === undefined ? length : end, length); + var result = $Array(max(fin - k, 0)); + var n = 0; + for (; k < fin; k++, n++) createProperty(result, n, O[k]); + result.length = n; + return result; + }; + + /* eslint-disable es/no-object-getownpropertynames -- safe */ + var classof$1 = classofRaw$2; + var toIndexedObject = toIndexedObject$6; + var $getOwnPropertyNames = objectGetOwnPropertyNames.f; + var arraySlice = arraySliceSimple; + + var windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames + ? Object.getOwnPropertyNames(window) : []; + + var getWindowNames = function (it) { + try { + return $getOwnPropertyNames(it); + } catch (error) { + return arraySlice(windowNames); + } + }; + + // fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window + objectGetOwnPropertyNamesExternal.f = function getOwnPropertyNames(it) { + return windowNames && classof$1(it) === 'Window' + ? getWindowNames(it) + : $getOwnPropertyNames(toIndexedObject(it)); + }; + + // FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it + var fails$3 = fails$j; + + var arrayBufferNonExtensible = fails$3(function () { + if (typeof ArrayBuffer == 'function') { + var buffer = new ArrayBuffer(8); + // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe + if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 }); + } + }); + + var fails$2 = fails$j; + var isObject$4 = isObject$f; + var classof = classofRaw$2; + var ARRAY_BUFFER_NON_EXTENSIBLE = arrayBufferNonExtensible; + + // eslint-disable-next-line es/no-object-isextensible -- safe + var $isExtensible = Object.isExtensible; + var FAILS_ON_PRIMITIVES = fails$2(function () { $isExtensible(1); }); + + // `Object.isExtensible` method + // https://tc39.es/ecma262/#sec-object.isextensible + var objectIsExtensible = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) { + if (!isObject$4(it)) return false; + if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false; + return $isExtensible ? $isExtensible(it) : true; + } : $isExtensible; + + var fails$1 = fails$j; + + var freezing = !fails$1(function () { + // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing + return Object.isExtensible(Object.preventExtensions({})); + }); + + var $$1 = _export; + var uncurryThis$3 = functionUncurryThis; + var hiddenKeys = hiddenKeys$5; + var isObject$3 = isObject$f; + var hasOwn$1 = hasOwnProperty_1; + var defineProperty = objectDefineProperty.f; + var getOwnPropertyNamesModule = objectGetOwnPropertyNames; + var getOwnPropertyNamesExternalModule = objectGetOwnPropertyNamesExternal; + var isExtensible = objectIsExtensible; + var uid = uid$3; + var FREEZING = freezing; + + var REQUIRED = false; + var METADATA = uid('meta'); + var id$1 = 0; + + var setMetadata = function (it) { + defineProperty(it, METADATA, { value: { + objectID: 'O' + id$1++, // object ID + weakData: {} // weak collections IDs + } }); + }; + + var fastKey = function (it, create) { + // return a primitive with prefix + if (!isObject$3(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it; + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return 'F'; + // not necessary to add metadata + if (!create) return 'E'; + // add missing metadata + setMetadata(it); + // return object ID + } return it[METADATA].objectID; + }; + + var getWeakData$1 = function (it, create) { + if (!hasOwn$1(it, METADATA)) { + // can't set metadata to uncaught frozen object + if (!isExtensible(it)) return true; + // not necessary to add metadata + if (!create) return false; + // add missing metadata + setMetadata(it); + // return the store of weak collections IDs + } return it[METADATA].weakData; + }; + + // add metadata on freeze-family methods calling + var onFreeze = function (it) { + if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn$1(it, METADATA)) setMetadata(it); + return it; + }; + + var enable = function () { + meta.enable = function () { /* empty */ }; + REQUIRED = true; + var getOwnPropertyNames = getOwnPropertyNamesModule.f; + var splice = uncurryThis$3([].splice); + var test = {}; + test[METADATA] = 1; + + // prevent exposing of metadata key + if (getOwnPropertyNames(test).length) { + getOwnPropertyNamesModule.f = function (it) { + var result = getOwnPropertyNames(it); + for (var i = 0, length = result.length; i < length; i++) { + if (result[i] === METADATA) { + splice(result, i, 1); + break; + } + } return result; + }; + + $$1({ target: 'Object', stat: true, forced: true }, { + getOwnPropertyNames: getOwnPropertyNamesExternalModule.f + }); + } + }; + + var meta = internalMetadata.exports = { + enable: enable, + fastKey: fastKey, + getWeakData: getWeakData$1, + onFreeze: onFreeze + }; + + hiddenKeys[METADATA] = true; + + var internalMetadataExports = internalMetadata.exports; + + var isCallable$1 = isCallable$m; + var isObject$2 = isObject$f; + var setPrototypeOf = objectSetPrototypeOf; + + // makes subclassing work correct for wrapped built-ins + var inheritIfRequired$1 = function ($this, dummy, Wrapper) { + var NewTarget, NewTargetPrototype; + if ( + // it can work only with native `setPrototypeOf` + setPrototypeOf && + // we haven't completely correct pre-ES6 way for getting `new.target`, so use this + isCallable$1(NewTarget = dummy.constructor) && + NewTarget !== Wrapper && + isObject$2(NewTargetPrototype = NewTarget.prototype) && + NewTargetPrototype !== Wrapper.prototype + ) setPrototypeOf($this, NewTargetPrototype); + return $this; + }; + + var $ = _export; + var global$2 = global$j; + var uncurryThis$2 = functionUncurryThis; + var isForced = isForced_1; + var defineBuiltIn$1 = defineBuiltIn$8; + var InternalMetadataModule = internalMetadataExports; + var iterate$1 = iterate$4; + var anInstance$1 = anInstance$3; + var isCallable = isCallable$m; + var isNullOrUndefined$1 = isNullOrUndefined$6; + var isObject$1 = isObject$f; + var fails = fails$j; + var checkCorrectnessOfIteration = checkCorrectnessOfIteration$2; + var setToStringTag$1 = setToStringTag$5; + var inheritIfRequired = inheritIfRequired$1; + + var collection$1 = function (CONSTRUCTOR_NAME, wrapper, common) { + var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1; + var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1; + var ADDER = IS_MAP ? 'set' : 'add'; + var NativeConstructor = global$2[CONSTRUCTOR_NAME]; + var NativePrototype = NativeConstructor && NativeConstructor.prototype; + var Constructor = NativeConstructor; + var exported = {}; + + var fixMethod = function (KEY) { + var uncurriedNativeMethod = uncurryThis$2(NativePrototype[KEY]); + defineBuiltIn$1(NativePrototype, KEY, + KEY === 'add' ? function add(value) { + uncurriedNativeMethod(this, value === 0 ? 0 : value); + return this; + } : KEY === 'delete' ? function (key) { + return IS_WEAK && !isObject$1(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'get' ? function get(key) { + return IS_WEAK && !isObject$1(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : KEY === 'has' ? function has(key) { + return IS_WEAK && !isObject$1(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key); + } : function set(key, value) { + uncurriedNativeMethod(this, key === 0 ? 0 : key, value); + return this; + } + ); + }; + + var REPLACE = isForced( + CONSTRUCTOR_NAME, + !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () { + new NativeConstructor().entries().next(); + })) + ); + + if (REPLACE) { + // create collection constructor + Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER); + InternalMetadataModule.enable(); + } else if (isForced(CONSTRUCTOR_NAME, true)) { + var instance = new Constructor(); + // early implementations not supports chaining + var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance; + // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false + var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); }); + // most early implementations doesn't supports iterables, most modern - not close it correctly + // eslint-disable-next-line no-new -- required for testing + var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); }); + // for early implementations -0 and +0 not the same + var BUGGY_ZERO = !IS_WEAK && fails(function () { + // V8 ~ Chromium 42- fails only with 5+ elements + var $instance = new NativeConstructor(); + var index = 5; + while (index--) $instance[ADDER](index, index); + return !$instance.has(-0); + }); + + if (!ACCEPT_ITERABLES) { + Constructor = wrapper(function (dummy, iterable) { + anInstance$1(dummy, NativePrototype); + var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor); + if (!isNullOrUndefined$1(iterable)) iterate$1(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + return that; + }); + Constructor.prototype = NativePrototype; + NativePrototype.constructor = Constructor; + } + + if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) { + fixMethod('delete'); + fixMethod('has'); + IS_MAP && fixMethod('get'); + } + + if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER); + + // weak collections should not contains .clear method + if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear; + } + + exported[CONSTRUCTOR_NAME] = Constructor; + $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported); + + setToStringTag$1(Constructor, CONSTRUCTOR_NAME); + + if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP); + + return Constructor; + }; + + var defineBuiltIn = defineBuiltIn$8; + + var defineBuiltIns$1 = function (target, src, options) { + for (var key in src) defineBuiltIn(target, key, src[key], options); + return target; + }; + + var bind = functionBindContext; + var uncurryThis$1 = functionUncurryThis; + var IndexedObject = indexedObject; + var toObject = toObject$5; + var lengthOfArrayLike = lengthOfArrayLike$5; + var arraySpeciesCreate = arraySpeciesCreate$2; + + var push = uncurryThis$1([].push); + + // `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation + var createMethod = function (TYPE) { + var IS_MAP = TYPE === 1; + var IS_FILTER = TYPE === 2; + var IS_SOME = TYPE === 3; + var IS_EVERY = TYPE === 4; + var IS_FIND_INDEX = TYPE === 6; + var IS_FILTER_REJECT = TYPE === 7; + var NO_HOLES = TYPE === 5 || IS_FIND_INDEX; + return function ($this, callbackfn, that, specificCreate) { + var O = toObject($this); + var self = IndexedObject(O); + var length = lengthOfArrayLike(self); + var boundFunction = bind(callbackfn, that); + var index = 0; + var create = specificCreate || arraySpeciesCreate; + var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined; + var value, result; + for (;length > index; index++) if (NO_HOLES || index in self) { + value = self[index]; + result = boundFunction(value, index, O); + if (TYPE) { + if (IS_MAP) target[index] = result; // map + else if (result) switch (TYPE) { + case 3: return true; // some + case 5: return value; // find + case 6: return index; // findIndex + case 2: push(target, value); // filter + } else switch (TYPE) { + case 4: return false; // every + case 7: push(target, value); // filterReject + } + } + } + return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target; + }; + }; + + var arrayIteration = { + // `Array.prototype.forEach` method + // https://tc39.es/ecma262/#sec-array.prototype.foreach + forEach: createMethod(0), + // `Array.prototype.map` method + // https://tc39.es/ecma262/#sec-array.prototype.map + map: createMethod(1), + // `Array.prototype.filter` method + // https://tc39.es/ecma262/#sec-array.prototype.filter + filter: createMethod(2), + // `Array.prototype.some` method + // https://tc39.es/ecma262/#sec-array.prototype.some + some: createMethod(3), + // `Array.prototype.every` method + // https://tc39.es/ecma262/#sec-array.prototype.every + every: createMethod(4), + // `Array.prototype.find` method + // https://tc39.es/ecma262/#sec-array.prototype.find + find: createMethod(5), + // `Array.prototype.findIndex` method + // https://tc39.es/ecma262/#sec-array.prototype.findIndex + findIndex: createMethod(6), + // `Array.prototype.filterReject` method + // https://github.com/tc39/proposal-array-filtering + filterReject: createMethod(7) + }; + + var uncurryThis = functionUncurryThis; + var defineBuiltIns = defineBuiltIns$1; + var getWeakData = internalMetadataExports.getWeakData; + var anInstance = anInstance$3; + var anObject = anObject$b; + var isNullOrUndefined = isNullOrUndefined$6; + var isObject = isObject$f; + var iterate = iterate$4; + var ArrayIterationModule = arrayIteration; + var hasOwn = hasOwnProperty_1; + var InternalStateModule = internalState; + + var setInternalState = InternalStateModule.set; + var internalStateGetterFor = InternalStateModule.getterFor; + var find = ArrayIterationModule.find; + var findIndex = ArrayIterationModule.findIndex; + var splice = uncurryThis([].splice); + var id = 0; + + // fallback for uncaught frozen keys + var uncaughtFrozenStore = function (state) { + return state.frozen || (state.frozen = new UncaughtFrozenStore()); + }; + + var UncaughtFrozenStore = function () { + this.entries = []; + }; + + var findUncaughtFrozen = function (store, key) { + return find(store.entries, function (it) { + return it[0] === key; + }); + }; + + UncaughtFrozenStore.prototype = { + get: function (key) { + var entry = findUncaughtFrozen(this, key); + if (entry) return entry[1]; + }, + has: function (key) { + return !!findUncaughtFrozen(this, key); + }, + set: function (key, value) { + var entry = findUncaughtFrozen(this, key); + if (entry) entry[1] = value; + else this.entries.push([key, value]); + }, + 'delete': function (key) { + var index = findIndex(this.entries, function (it) { + return it[0] === key; + }); + if (~index) splice(this.entries, index, 1); + return !!~index; + } + }; + + var collectionWeak$1 = { + getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) { + var Constructor = wrapper(function (that, iterable) { + anInstance(that, Prototype); + setInternalState(that, { + type: CONSTRUCTOR_NAME, + id: id++, + frozen: undefined + }); + if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP }); + }); + + var Prototype = Constructor.prototype; + + var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME); + + var define = function (that, key, value) { + var state = getInternalState(that); + var data = getWeakData(anObject(key), true); + if (data === true) uncaughtFrozenStore(state).set(key, value); + else data[state.id] = value; + return that; + }; + + defineBuiltIns(Prototype, { + // `{ WeakMap, WeakSet }.prototype.delete(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.delete + // https://tc39.es/ecma262/#sec-weakset.prototype.delete + 'delete': function (key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state)['delete'](key); + return data && hasOwn(data, state.id) && delete data[state.id]; + }, + // `{ WeakMap, WeakSet }.prototype.has(key)` methods + // https://tc39.es/ecma262/#sec-weakmap.prototype.has + // https://tc39.es/ecma262/#sec-weakset.prototype.has + has: function has(key) { + var state = getInternalState(this); + if (!isObject(key)) return false; + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).has(key); + return data && hasOwn(data, state.id); + } + }); + + defineBuiltIns(Prototype, IS_MAP ? { + // `WeakMap.prototype.get(key)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.get + get: function get(key) { + var state = getInternalState(this); + if (isObject(key)) { + var data = getWeakData(key); + if (data === true) return uncaughtFrozenStore(state).get(key); + return data ? data[state.id] : undefined; + } + }, + // `WeakMap.prototype.set(key, value)` method + // https://tc39.es/ecma262/#sec-weakmap.prototype.set + set: function set(key, value) { + return define(this, key, value); + } + } : { + // `WeakSet.prototype.add(value)` method + // https://tc39.es/ecma262/#sec-weakset.prototype.add + add: function add(value) { + return define(this, value, true); + } + }); + + return Constructor; + } + }; + + var collection = collection$1; + var collectionWeak = collectionWeak$1; + + // `WeakSet` constructor + // https://tc39.es/ecma262/#sec-weakset-constructor + collection('WeakSet', function (init) { + return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); }; + }, collectionWeak); + + // iterable DOM collections + // flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods + var domIterables = { + CSSRuleList: 0, + CSSStyleDeclaration: 0, + CSSValueList: 0, + ClientRectList: 0, + DOMRectList: 0, + DOMStringList: 0, + DOMTokenList: 1, + DataTransferItemList: 0, + FileList: 0, + HTMLAllCollection: 0, + HTMLCollection: 0, + HTMLFormElement: 0, + HTMLSelectElement: 0, + MediaList: 0, + MimeTypeArray: 0, + NamedNodeMap: 0, + NodeList: 1, + PaintRequestList: 0, + Plugin: 0, + PluginArray: 0, + SVGLengthList: 0, + SVGNumberList: 0, + SVGPathSegList: 0, + SVGPointList: 0, + SVGStringList: 0, + SVGTransformList: 0, + SourceBufferList: 0, + StyleSheetList: 0, + TextTrackCueList: 0, + TextTrackList: 0, + TouchList: 0 + }; + + // in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList` + var documentCreateElement = documentCreateElement$2; + + var classList = documentCreateElement('span').classList; + var DOMTokenListPrototype$1 = classList && classList.constructor && classList.constructor.prototype; + + var domTokenListPrototype = DOMTokenListPrototype$1 === Object.prototype ? undefined : DOMTokenListPrototype$1; + + var global$1 = global$j; + var DOMIterables = domIterables; + var DOMTokenListPrototype = domTokenListPrototype; + var ArrayIteratorMethods = es_array_iterator; + var createNonEnumerableProperty = createNonEnumerableProperty$4; + var setToStringTag = setToStringTag$5; + var wellKnownSymbol = wellKnownSymbol$h; + + var ITERATOR = wellKnownSymbol('iterator'); + var ArrayValues = ArrayIteratorMethods.values; + + var handlePrototype = function (CollectionPrototype, COLLECTION_NAME) { + if (CollectionPrototype) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[ITERATOR] !== ArrayValues) try { + createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues); + } catch (error) { + CollectionPrototype[ITERATOR] = ArrayValues; + } + setToStringTag(CollectionPrototype, COLLECTION_NAME, true); + if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) { + // some Chrome versions have non-configurable methods on DOMTokenList + if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try { + createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]); + } catch (error) { + CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME]; + } + } + } + }; + + for (var COLLECTION_NAME in DOMIterables) { + handlePrototype(global$1[COLLECTION_NAME] && global$1[COLLECTION_NAME].prototype, COLLECTION_NAME); + } + + handlePrototype(DOMTokenListPrototype, 'DOMTokenList'); + + /****************************************************************************** + Copyright (c) Microsoft Corporation. + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted. + + THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH + REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY + AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, + INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM + LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR + OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR + PERFORMANCE OF THIS SOFTWARE. + ***************************************************************************** */ + /* global Reflect, Promise */ + + + function __classPrivateFieldGet(receiver, state, kind, f) { + if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter"); + if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it"); + return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); + } + + var _Tooltip_instances, _Tooltip_show, _Tooltip_hide; + var DEFAULT_SELECTOR = '#ch-tooltip'; + var defaultOptions = { + enabled: true, + // Expecting a function, which will return the tooltip content + text: function text(_timestamp, value, dayjsDate) { + return (// eslint-disable-next-line implicit-arrow-linebreak + "".concat(value, " - ").concat(dayjsDate.format('LLLL')) + ); + } + }; + var DEFAULT_POPPER_OPTIONS = { + placement: 'top', + modifiers: [{ + name: 'offset', + options: { + offset: [0, 8] + } + }] + }; + var virtualElement = { + getBoundingClientRect: function getBoundingClientRect() { + var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0; + var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0; + return { + width: 0, + height: 0, + top: y, + right: x, + bottom: y, + left: x, + x: x, + y: y, + toJSON: function toJSON() {} + }; + } + }; + var Tooltip = /*#__PURE__*/function () { + function Tooltip(calendar) { + _classCallCheck(this, Tooltip); + _Tooltip_instances.add(this); + this.name = 'Tooltip'; + this.calendar = calendar; + this.root = null; + this.popperInstance = null; + this.options = defaultOptions; + this.listenerAttached = false; + } + _createClass(Tooltip, [{ + key: "setup", + value: function setup(pluginOptions) { + this.options = Object.assign(Object.assign({}, defaultOptions), pluginOptions); + var event = this.calendar.eventEmitter; + if (!this.options.enabled) { + if (this.listenerAttached) { + event.off('mouseover', this.mouseOverCallback, this); + event.off('mouseout', this.mouseOutCallback, this); + this.listenerAttached = false; + } + this.destroy(); + return; + } + this.popperOptions = Object.assign(Object.assign({}, DEFAULT_POPPER_OPTIONS), this.options); + this.root = document.getElementById(DEFAULT_SELECTOR.slice(1)); + if (!this.root) { + var tooltipElem = document.createElement('div'); + tooltipElem.setAttribute('id', DEFAULT_SELECTOR.slice(1)); + tooltipElem.setAttribute('role', 'tooltip'); + tooltipElem.innerHTML = "
") + ""); + this.root = document.body.appendChild(tooltipElem); + } + this.root.setAttribute('data-theme', this.calendar.options.options.theme); + this.popperInstance = core.createPopper(virtualElement, this.root, this.popperOptions); + if (!this.listenerAttached) { + event.on('mouseover', this.mouseOverCallback, this); + event.on('mouseout', this.mouseOutCallback, this); + this.listenerAttached = true; + } + } + }, { + key: "mouseOverCallback", + value: function mouseOverCallback(e, timestamp, value) { + __classPrivateFieldGet(this, _Tooltip_instances, "m", _Tooltip_show).call(this, e.target, timestamp, value); + } + }, { + key: "mouseOutCallback", + value: function mouseOutCallback() { + __classPrivateFieldGet(this, _Tooltip_instances, "m", _Tooltip_hide).call(this); + } + // eslint-disable-next-line class-methods-use-this + }, { + key: "paint", + value: function paint() { + return Promise.resolve(); + } + }, { + key: "destroy", + value: function destroy() { + if (this.root) { + this.root.remove(); + } + return Promise.resolve(); + } + }]); + return Tooltip; + }(); + _Tooltip_instances = new WeakSet(), _Tooltip_show = function _Tooltip_show(e, timestamp, value) { + var _this = this; + var formatter = this.options.text; + var title = formatter ? formatter(timestamp, value, this.calendar.dateHelper.date(timestamp)) : null; + if (!title) { + return; + } + virtualElement.getBoundingClientRect = function () { + return e.getBoundingClientRect(); + }; + document.getElementById("".concat(DEFAULT_SELECTOR.slice(1), "-body")).innerHTML = title; + this.popperInstance.setOptions(function () { + return Object.assign(Object.assign({}, _this.popperOptions), { + modifiers: [].concat(_toConsumableArray(_this.popperOptions.modifiers), [{ + name: 'eventListeners', + enabled: true + }]) + }); + }); + this.popperInstance.update(); + this.root.setAttribute('data-show', '1'); + }, _Tooltip_hide = function _Tooltip_hide() { + var _this2 = this; + this.root.removeAttribute('data-show'); + this.popperInstance.setOptions(function () { + return Object.assign(Object.assign({}, _this2.popperOptions), { + modifiers: [].concat(_toConsumableArray(_this2.popperOptions.modifiers), [{ + name: 'eventListeners', + enabled: false + }]) + }); + }); + }; + + return Tooltip; + +})); diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.esm.js b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.esm.js new file mode 100644 index 0000000..9455496 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.esm.js @@ -0,0 +1 @@ +import{createPopper as t}from"@popperjs/core";function e(t,e){for(var n=0;nt.length)&&(e=t.length);for(var n=0,r=new Array(e);n0&&m[0]<4?1:+(m[0]+m[1])),!g&&et&&(!(m=et.match(/Edge\/(\d+)/))||m[1]>=74)&&(m=et.match(/Chrome\/(\d+)/))&&(g=+m[1]);var ct=g,ut=ct,at=a,ft=c.String,st=!!Object.getOwnPropertySymbols&&!at((function(){var t=Symbol("symbol detection");return!ft(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&ut&&ut<41})),lt=st&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,pt=$,ht=V,vt=Q,dt=Object,yt=lt?function(t){return"symbol"==typeof t}:function(t){var e=pt("Symbol");return ht(e)&&vt(e.prototype,dt(t))},bt=String,mt=function(t){try{return bt(t)}catch(t){return"Object"}},gt=V,wt=mt,Ot=TypeError,St=function(t){if(gt(t))return t;throw new Ot(wt(t)+" is not a function")},jt=St,Tt=N,Et=function(t,e){var n=t[e];return Tt(n)?void 0:jt(n)},Pt=h,At=V,Ct=K,It=TypeError,xt={exports:{}},Lt=c,Rt=Object.defineProperty,kt=function(t,e){try{Rt(Lt,t,{value:e,configurable:!0,writable:!0})}catch(n){Lt[t]=e}return e},Mt=kt,Nt="__core-js_shared__",_t=c[Nt]||Mt(Nt,{}),Dt=_t;(xt.exports=function(t,e){return Dt[t]||(Dt[t]=void 0!==e?e:{})})("versions",[]).push({version:"3.34.0",mode:"global",copyright:"© 2014-2023 Denis Pushkarev (zloirock.ru)",license:"https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE",source:"https://github.com/zloirock/core-js"});var Ft=xt.exports,Bt=F,Gt=Object,Ut=function(t){return Gt(Bt(t))},zt=Ut,Wt=E({}.hasOwnProperty),Ht=Object.hasOwn||function(t,e){return Wt(zt(t),e)},Vt=E,qt=0,Jt=Math.random(),Kt=Vt(1..toString),Xt=function(t){return"Symbol("+(void 0===t?"":t)+")_"+Kt(++qt+Jt,36)},Yt=Ft,$t=Ht,Qt=Xt,Zt=st,te=lt,ee=c.Symbol,ne=Yt("wks"),re=te?ee.for||ee:ee&&ee.withoutSetter||Qt,oe=function(t){return $t(ne,t)||(ne[t]=Zt&&$t(ee,t)?ee[t]:re("Symbol."+t)),ne[t]},ie=h,ce=K,ue=yt,ae=Et,fe=function(t,e){var n,r;if("string"===e&&At(n=t.toString)&&!Ct(r=Pt(n,t)))return r;if(At(n=t.valueOf)&&!Ct(r=Pt(n,t)))return r;if("string"!==e&&At(n=t.toString)&&!Ct(r=Pt(n,t)))return r;throw new It("Can't convert object to primitive value")},se=TypeError,le=oe("toPrimitive"),pe=function(t,e){if(!ce(t)||ue(t))return t;var n,r=ae(t,le);if(r){if(void 0===e&&(e="default"),n=ie(r,t,e),!ce(n)||ue(n))return n;throw new se("Can't convert object to primitive value")}return void 0===e&&(e="number"),fe(t,e)},he=yt,ve=function(t){var e=pe(t,"string");return he(e)?e:e+""},de=K,ye=c.document,be=de(ye)&&de(ye.createElement),me=function(t){return be?ye.createElement(t):{}},ge=me,we=!f&&!a((function(){return 7!==Object.defineProperty(ge("div"),"a",{get:function(){return 7}}).a})),Oe=f,Se=h,je=v,Te=w,Ee=U,Pe=ve,Ae=Ht,Ce=we,Ie=Object.getOwnPropertyDescriptor;u.f=Oe?Ie:function(t,e){if(t=Ee(t),e=Pe(e),Ce)try{return Ie(t,e)}catch(t){}if(Ae(t,e))return Te(!Se(je.f,t,e),t[e])};var xe={},Le=f&&a((function(){return 42!==Object.defineProperty((function(){}),"prototype",{value:42,writable:!1}).prototype})),Re=K,ke=String,Me=TypeError,Ne=function(t){if(Re(t))return t;throw new Me(ke(t)+" is not an object")},_e=f,De=we,Fe=Le,Be=Ne,Ge=ve,Ue=TypeError,ze=Object.defineProperty,We=Object.getOwnPropertyDescriptor,He="enumerable",Ve="configurable",qe="writable";xe.f=_e?Fe?function(t,e,n){if(Be(t),e=Ge(e),Be(n),"function"==typeof t&&"prototype"===e&&"value"in n&&qe in n&&!n[qe]){var r=We(t,e);r&&r[qe]&&(t[e]=n.value,n={configurable:Ve in n?n[Ve]:r[Ve],enumerable:He in n?n[He]:r[He],writable:!1})}return ze(t,e,n)}:ze:function(t,e,n){if(Be(t),e=Ge(e),Be(n),De)try{return ze(t,e,n)}catch(t){}if("get"in n||"set"in n)throw new Ue("Accessors not supported");return"value"in n&&(t[e]=n.value),t};var Je=xe,Ke=w,Xe=f?function(t,e,n){return Je.f(t,e,Ke(1,n))}:function(t,e,n){return t[e]=n,t},Ye={exports:{}},$e=f,Qe=Ht,Ze=Function.prototype,tn=$e&&Object.getOwnPropertyDescriptor,en=Qe(Ze,"name"),nn={EXISTS:en,PROPER:en&&"something"===function(){}.name,CONFIGURABLE:en&&(!$e||$e&&tn(Ze,"name").configurable)},rn=V,on=_t,cn=E(Function.toString);rn(on.inspectSource)||(on.inspectSource=function(t){return cn(t)});var un,an,fn,sn=on.inspectSource,ln=V,pn=c.WeakMap,hn=ln(pn)&&/native code/.test(String(pn)),vn=Xt,dn=Ft("keys"),yn=function(t){return dn[t]||(dn[t]=vn(t))},bn={},mn=hn,gn=c,wn=K,On=Xe,Sn=Ht,jn=_t,Tn=yn,En=bn,Pn="Object already initialized",An=gn.TypeError,Cn=gn.WeakMap;if(mn||jn.state){var In=jn.state||(jn.state=new Cn);In.get=In.get,In.has=In.has,In.set=In.set,un=function(t,e){if(In.has(t))throw new An(Pn);return e.facade=t,In.set(t,e),e},an=function(t){return In.get(t)||{}},fn=function(t){return In.has(t)}}else{var xn=Tn("state");En[xn]=!0,un=function(t,e){if(Sn(t,xn))throw new An(Pn);return e.facade=t,On(t,xn,e),e},an=function(t){return Sn(t,xn)?t[xn]:{}},fn=function(t){return Sn(t,xn)}}var Ln={set:un,get:an,has:fn,enforce:function(t){return fn(t)?an(t):un(t,{})},getterFor:function(t){return function(e){var n;if(!wn(e)||(n=an(e)).type!==t)throw new An("Incompatible receiver, "+t+" required");return n}}},Rn=E,kn=a,Mn=V,Nn=Ht,_n=f,Dn=nn.CONFIGURABLE,Fn=sn,Bn=Ln.enforce,Gn=Ln.get,Un=String,zn=Object.defineProperty,Wn=Rn("".slice),Hn=Rn("".replace),Vn=Rn([].join),qn=_n&&!kn((function(){return 8!==zn((function(){}),"length",{value:8}).length})),Jn=String(String).split("String"),Kn=Ye.exports=function(t,e,n){"Symbol("===Wn(Un(e),0,7)&&(e="["+Hn(Un(e),/^Symbol\(([^)]*)\)/,"$1")+"]"),n&&n.getter&&(e="get "+e),n&&n.setter&&(e="set "+e),(!Nn(t,"name")||Dn&&t.name!==e)&&(_n?zn(t,"name",{value:e,configurable:!0}):t.name=e),qn&&n&&Nn(n,"arity")&&t.length!==n.arity&&zn(t,"length",{value:n.arity});try{n&&Nn(n,"constructor")&&n.constructor?_n&&zn(t,"prototype",{writable:!1}):t.prototype&&(t.prototype=void 0)}catch(t){}var r=Bn(t);return Nn(r,"source")||(r.source=Vn(Jn,"string"==typeof e?e:"")),t};Function.prototype.toString=Kn((function(){return Mn(this)&&Gn(this).source||Fn(this)}),"toString");var Xn=Ye.exports,Yn=V,$n=xe,Qn=Xn,Zn=kt,tr=function(t,e,n,r){r||(r={});var o=r.enumerable,i=void 0!==r.name?r.name:e;if(Yn(n)&&Qn(n,i,r),r.global)o?t[e]=n:Zn(e,n);else{try{r.unsafe?t[e]&&(o=!0):delete t[e]}catch(t){}o?t[e]=n:$n.f(t,e,{value:n,enumerable:!1,configurable:!r.nonConfigurable,writable:!r.nonWritable})}return t},er={},nr=Math.ceil,rr=Math.floor,or=Math.trunc||function(t){var e=+t;return(e>0?rr:nr)(e)},ir=function(t){var e=+t;return e!=e||0===e?0:or(e)},cr=ir,ur=Math.max,ar=Math.min,fr=function(t,e){var n=cr(t);return n<0?ur(n+e,0):ar(n,e)},sr=ir,lr=Math.min,pr=function(t){return t>0?lr(sr(t),9007199254740991):0},hr=function(t){return pr(t.length)},vr=U,dr=fr,yr=hr,br=function(t){return function(e,n,r){var o,i=vr(e),c=yr(i),u=dr(r,c);if(t&&n!=n){for(;c>u;)if((o=i[u++])!=o)return!0}else for(;c>u;u++)if((t||u in i)&&i[u]===n)return t||u||0;return!t&&-1}},mr={includes:br(!0),indexOf:br(!1)},gr=Ht,wr=U,Or=mr.indexOf,Sr=bn,jr=E([].push),Tr=function(t,e){var n,r=wr(t),o=0,i=[];for(n in r)!gr(Sr,n)&&gr(r,n)&&jr(i,n);for(;e.length>o;)gr(r,n=e[o++])&&(~Or(i,n)||jr(i,n));return i},Er=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],Pr=Tr,Ar=Er.concat("length","prototype");er.f=Object.getOwnPropertyNames||function(t){return Pr(t,Ar)};var Cr={};Cr.f=Object.getOwnPropertySymbols;var Ir=$,xr=er,Lr=Cr,Rr=Ne,kr=E([].concat),Mr=Ir("Reflect","ownKeys")||function(t){var e=xr.f(Rr(t)),n=Lr.f;return n?kr(e,n(t)):e},Nr=Ht,_r=Mr,Dr=u,Fr=xe,Br=a,Gr=V,Ur=/#|\.prototype\./,zr=function(t,e){var n=Hr[Wr(t)];return n===qr||n!==Vr&&(Gr(e)?Br(e):!!e)},Wr=zr.normalize=function(t){return String(t).replace(Ur,".").toLowerCase()},Hr=zr.data={},Vr=zr.NATIVE="N",qr=zr.POLYFILL="P",Jr=zr,Kr=c,Xr=u.f,Yr=Xe,$r=tr,Qr=kt,Zr=function(t,e,n){for(var r=_r(e),o=Fr.f,i=Dr.f,c=0;c9007199254740991)throw oo("Maximum allowed index exceeded");return t},Yo=ao,$o=Bo,Qo=function(t){return Uo>=51||!Go((function(){var e=[];return(e.constructor={})[zo]=function(){return{foo:1}},1!==e[t](Boolean).foo}))},Zo=ct,ti=oe("isConcatSpreadable"),ei=Zo>=51||!Ho((function(){var t=[];return t[ti]=!1,t.concat()[0]!==t})),ni=function(t){if(!qo(t))return!1;var e=t[ti];return void 0!==e?!!e:Vo(t)};Wo({target:"Array",proto:!0,arity:1,forced:!ei||!Qo("concat")},{concat:function(t){var e,n,r,o,i,c=Jo(this),u=$o(c,0),a=0;for(e=-1,r=arguments.length;eo;)for(var u,a=Ei(arguments[o++]),f=i?Ci(Oi(a),i(a)):Oi(a),s=f.length,l=0;s>l;)u=f[l++],bi&&!gi(c,a,u)||(n[u]=a[u]);return n}:Pi,xi=Ii;eo({target:"Object",stat:!0,arity:2,forced:Object.assign!==xi},{assign:xi});var Li=mo,Ri=so?{}.toString:function(){return"[object "+Li(this)+"]"};so||tr(Object.prototype,"toString",Ri,{unsafe:!0});var ki,Mi,Ni,_i,Di="process"===I(c.process),Fi=E,Bi=St,Gi=V,Ui=String,zi=TypeError,Wi=function(t,e,n){try{return Fi(Bi(Object.getOwnPropertyDescriptor(t,e)[n]))}catch(t){}},Hi=Ne,Vi=function(t){if("object"==typeof t||Gi(t))return t;throw new zi("Can't set "+Ui(t)+" as a prototype")},qi=Object.setPrototypeOf||("__proto__"in{}?function(){var t,e=!1,n={};try{(t=Wi(Object.prototype,"__proto__","set"))(n,[]),e=n instanceof Array}catch(t){}return function(n,r){return Hi(n),Vi(r),e?t(n,r):n.__proto__=r,n}}():void 0),Ji=xe.f,Ki=Ht,Xi=oe("toStringTag"),Yi=function(t,e,n){t&&!n&&(t=t.prototype),t&&!Ki(t,Xi)&&Ji(t,Xi,{configurable:!0,value:e})},$i=$,Qi=ii,Zi=f,tc=oe("species"),ec=Q,nc=TypeError,rc=function(t,e){if(ec(e,t))return t;throw new nc("Incorrect invocation")},oc=Ro,ic=mt,cc=TypeError,uc=Ne,ac=function(t){if(oc(t))return t;throw new cc(ic(t)+" is not a constructor")},fc=N,sc=oe("species"),lc=s,pc=Function.prototype,hc=pc.apply,vc=pc.call,dc="object"==typeof Reflect&&Reflect.apply||(lc?vc.bind(hc):function(){return vc.apply(hc,arguments)}),yc=I,bc=E,mc=function(t){if("Function"===yc(t))return bc(t)},gc=St,wc=s,Oc=mc(mc.bind),Sc=function(t,e){return gc(t),void 0===e?t:wc?Oc(t,e):function(){return t.apply(e,arguments)}},jc=$("document","documentElement"),Tc=E([].slice),Ec=TypeError,Pc=/(?:ipad|iphone|ipod).*applewebkit/i.test(Z),Ac=c,Cc=dc,Ic=Sc,xc=V,Lc=Ht,Rc=a,kc=jc,Mc=Tc,Nc=me,_c=function(t,e){if(ti;i++)if((u=b(t[i]))&&bf(jf,u))return u;return new Sf(!1)}r=mf(t,o)}for(a=p?t.next:r.next;!(f=pf(a,r)).done;){try{u=b(f.value)}catch(t){wf(r,"throw",t)}if("object"==typeof u&&u&&bf(jf,u))return u}return new Sf(!1)},Ef=oe("iterator"),Pf=!1;try{var Af=0,Cf={next:function(){return{done:!!Af++}},return:function(){Pf=!0}};Cf[Ef]=function(){return this},Array.from(Cf,(function(){throw 2}))}catch(t){}var If=function(t,e){try{if(!e&&!Pf)return!1}catch(t){return!1}var n=!1;try{var r={};r[Ef]=function(){return{next:function(){return{done:n=!0}}}},t(r)}catch(t){}return n},xf=Cu,Lf=Hu.CONSTRUCTOR||!If((function(t){xf.all(t).then(void 0,(function(){}))})),Rf=h,kf=St,Mf=Vu,Nf=Au,_f=Tf;eo({target:"Promise",stat:!0,forced:Lf},{all:function(t){var e=this,n=Mf.f(e),r=n.resolve,o=n.reject,i=Nf((function(){var n=kf(e.resolve),i=[],c=0,u=1;_f(t,(function(t){var a=c++,f=!1;u++,Rf(n,e,t).then((function(t){f||(f=!0,i[a]=t,--u||r(i))}),o)})),--u||r(i)}));return i.error&&o(i.value),n.promise}});var Df=eo,Ff=Hu.CONSTRUCTOR,Bf=Cu,Gf=$,Uf=V,zf=tr,Wf=Bf&&Bf.prototype;if(Df({target:"Promise",proto:!0,forced:Ff,real:!0},{catch:function(t){return this.then(void 0,t)}}),Uf(Bf)){var Hf=Gf("Promise").prototype.catch;Wf.catch!==Hf&&zf(Wf,"catch",Hf,{unsafe:!0})}var Vf=h,qf=St,Jf=Vu,Kf=Au,Xf=Tf;eo({target:"Promise",stat:!0,forced:Lf},{race:function(t){var e=this,n=Jf.f(e),r=n.reject,o=Kf((function(){var o=qf(e.resolve);Xf(t,(function(t){Vf(o,e,t).then(n.resolve,r)}))}));return o.error&&r(o.value),n.promise}});var Yf=h,$f=Vu;eo({target:"Promise",stat:!0,forced:Hu.CONSTRUCTOR},{reject:function(t){var e=$f.f(this);return Yf(e.reject,void 0,t),e.promise}});var Qf=Ne,Zf=K,ts=Vu,es=eo,ns=Hu.CONSTRUCTOR,rs=function(t,e){if(Qf(t),Zf(e)&&e.constructor===t)return e;var n=ts.f(t);return(0,n.resolve)(e),n.promise};$("Promise"),es({target:"Promise",stat:!0,forced:ns},{resolve:function(t){return rs(this,t)}});var os={},is=f,cs=Le,us=xe,as=Ne,fs=U,ss=yi;os.f=is&&!cs?Object.defineProperties:function(t,e){as(t);for(var n,r=fs(e),o=ss(e),i=o.length,c=0;i>c;)us.f(t,n=o[c++],r[n]);return t};var ls,ps=Ne,hs=os,vs=Er,ds=bn,ys=jc,bs=me,ms="prototype",gs="script",ws=yn("IE_PROTO"),Os=function(){},Ss=function(t){return"<"+gs+">"+t+""},js=function(t){t.write(Ss("")),t.close();var e=t.parentWindow.Object;return t=null,e},Ts=function(){try{ls=new ActiveXObject("htmlfile")}catch(t){}var t,e,n;Ts="undefined"!=typeof document?document.domain&&ls?js(ls):(e=bs("iframe"),n="java"+gs+":",e.style.display="none",ys.appendChild(e),e.src=String(n),(t=e.contentWindow.document).open(),t.write(Ss("document.F=Object")),t.close(),t.F):js(ls);for(var r=vs.length;r--;)delete Ts[ms][vs[r]];return Ts()};ds[ws]=!0;var Es=Object.create||function(t,e){var n;return null!==t?(Os[ms]=ps(t),n=new Os,Os[ms]=null,n[ws]=t):n=Ts(),void 0===e?n:hs.f(n,e)},Ps=oe,As=Es,Cs=xe.f,Is=Ps("unscopables"),xs=Array.prototype;void 0===xs[Is]&&Cs(xs,Is,{configurable:!0,value:As(null)});var Ls,Rs,ks,Ms=!a((function(){function t(){}return t.prototype.constructor=null,Object.getPrototypeOf(new t)!==t.prototype})),Ns=Ht,_s=V,Ds=Ut,Fs=Ms,Bs=yn("IE_PROTO"),Gs=Object,Us=Gs.prototype,zs=Fs?Gs.getPrototypeOf:function(t){var e=Ds(t);if(Ns(e,Bs))return e[Bs];var n=e.constructor;return _s(n)&&e instanceof n?n.prototype:e instanceof Gs?Us:null},Ws=a,Hs=V,Vs=K,qs=zs,Js=tr,Ks=oe("iterator"),Xs=!1;[].keys&&("next"in(ks=[].keys())?(Rs=qs(qs(ks)))!==Object.prototype&&(Ls=Rs):Xs=!0);var Ys=!Vs(Ls)||Ws((function(){var t={};return Ls[Ks].call(t)!==t}));Ys&&(Ls={}),Hs(Ls[Ks])||Js(Ls,Ks,(function(){return this}));var $s={IteratorPrototype:Ls,BUGGY_SAFARI_ITERATORS:Xs},Qs=$s.IteratorPrototype,Zs=Es,tl=w,el=Yi,nl=Va,rl=function(){return this},ol=eo,il=h,cl=V,ul=function(t,e,n,r){var o=e+" Iterator";return t.prototype=Zs(Qs,{next:tl(+!r,n)}),el(t,o,!1),nl[o]=rl,t},al=zs,fl=qi,sl=Yi,ll=Xe,pl=tr,hl=Va,vl=nn.PROPER,dl=nn.CONFIGURABLE,yl=$s.IteratorPrototype,bl=$s.BUGGY_SAFARI_ITERATORS,ml=oe("iterator"),gl="keys",wl="values",Ol="entries",Sl=function(){return this},jl=function(t,e,n,r,o,i,c){ul(n,e,r);var u,a,f,s=function(t){if(t===o&&d)return d;if(!bl&&t&&t in h)return h[t];switch(t){case gl:case wl:case Ol:return function(){return new n(this,t)}}return function(){return new n(this)}},l=e+" Iterator",p=!1,h=t.prototype,v=h[ml]||h["@@iterator"]||o&&h[o],d=!bl&&v||s(o),y="Array"===e&&h.entries||v;if(y&&(u=al(y.call(new t)))!==Object.prototype&&u.next&&(al(u)!==yl&&(fl?fl(u,yl):cl(u[ml])||pl(u,ml,Sl)),sl(u,l,!0)),vl&&o===wl&&v&&v.name!==wl&&(dl?ll(h,"name",wl):(p=!0,d=function(){return il(v,this)})),o)if(a={values:s(wl),keys:i?d:s(gl),entries:s(Ol)},c)for(f in a)(bl||p||!(f in h))&&pl(h,f,a[f]);else ol({target:e,proto:!0,forced:bl||p},a);return h[ml]!==d&&pl(h,ml,d,{name:o}),hl[e]=d,a},Tl=function(t,e){return{value:t,done:e}},El=U,Pl=function(t){xs[Is][t]=!0},Al=Va,Cl=Ln,Il=xe.f,xl=jl,Ll=Tl,Rl=f,kl="Array Iterator",Ml=Cl.set,Nl=Cl.getterFor(kl),_l=xl(Array,"Array",(function(t,e){Ml(this,{type:kl,target:El(t),index:0,kind:e})}),(function(){var t=Nl(this),e=t.target,n=t.index++;if(!e||n>=e.length)return t.target=void 0,Ll(void 0,!0);switch(t.kind){case"keys":return Ll(n,!1);case"values":return Ll(e[n],!1)}return Ll([n,e[n]],!1)}),"values"),Dl=Al.Arguments=Al.Array;if(Pl("keys"),Pl("values"),Pl("entries"),Rl&&"values"!==Dl.name)try{Il(Dl,"name",{value:"values"})}catch(t){}var Fl=mo,Bl=String,Gl=function(t){if("Symbol"===Fl(t))throw new TypeError("Cannot convert a Symbol value to a string");return Bl(t)},Ul=E,zl=ir,Wl=Gl,Hl=F,Vl=Ul("".charAt),ql=Ul("".charCodeAt),Jl=Ul("".slice),Kl=function(t){return function(e,n){var r,o,i=Wl(Hl(e)),c=zl(n),u=i.length;return c<0||c>=u?t?"":void 0:(r=ql(i,c))<55296||r>56319||c+1===u||(o=ql(i,c+1))<56320||o>57343?t?Vl(i,c):r:t?Jl(i,c,c+2):o-56320+(r-55296<<10)+65536}},Xl={codeAt:Kl(!1),charAt:Kl(!0)}.charAt,Yl=Gl,$l=Ln,Ql=jl,Zl=Tl,tp="String Iterator",ep=$l.set,np=$l.getterFor(tp);Ql(String,"String",(function(t){ep(this,{type:tp,string:Yl(t),index:0})}),(function(){var t,e=np(this),n=e.string,r=e.index;return r>=n.length?Zl(void 0,!0):(t=Xl(n,r),e.index+=t.length,Zl(t,!1))}));var rp={exports:{}},op={},ip=fr,cp=hr,up=ao,ap=Array,fp=Math.max,sp=I,lp=U,pp=er.f,hp=function(t,e,n){for(var r=cp(t),o=ip(e,r),i=ip(void 0===n?r:n,r),c=ap(fp(i-o,0)),u=0;om;m++)if((u||m in d)&&(h=b(p=d[m],m,v),t))if(e)w[m]=h;else if(h)switch(t){case 3:return!0;case 5:return p;case 6:return m;case 2:fh(w,p)}else switch(t){case 4:return!1;case 7:fh(w,p)}return i?-1:r||o?o:w}},lh={forEach:sh(0),map:sh(1),filter:sh(2),some:sh(3),every:sh(4),find:sh(5),findIndex:sh(6),filterReject:sh(7)},ph=E,hh=function(t,e,n){for(var r in e)rh(t,r,e[r],n);return t},vh=Fp.getWeakData,dh=rc,yh=Ne,bh=N,mh=K,gh=Tf,wh=Ht,Oh=Ln.set,Sh=Ln.getterFor,jh=lh.find,Th=lh.findIndex,Eh=ph([].splice),Ph=0,Ah=function(t){return t.frozen||(t.frozen=new Ch)},Ch=function(){this.entries=[]},Ih=function(t,e){return jh(t.entries,(function(t){return t[0]===e}))};Ch.prototype={get:function(t){var e=Ih(this,t);if(e)return e[1]},has:function(t){return!!Ih(this,t)},set:function(t,e){var n=Ih(this,t);n?n[1]=e:this.entries.push([t,e])},delete:function(t){var e=Th(this.entries,(function(e){return e[0]===t}));return~e&&Eh(this.entries,e,1),!!~e}};var xh={getConstructor:function(t,e,n,r){var o=t((function(t,o){dh(t,i),Oh(t,{type:e,id:Ph++,frozen:void 0}),bh(o)||gh(o,t[r],{that:t,AS_ENTRIES:n})})),i=o.prototype,c=Sh(e),u=function(t,e,n){var r=c(t),o=vh(yh(e),!0);return!0===o?Ah(r).set(e,n):o[r.id]=n,t};return hh(i,{delete:function(t){var e=c(this);if(!mh(t))return!1;var n=vh(t);return!0===n?Ah(e).delete(t):n&&wh(n,e.id)&&delete n[e.id]},has:function(t){var e=c(this);if(!mh(t))return!1;var n=vh(t);return!0===n?Ah(e).has(t):n&&wh(n,e.id)}}),hh(i,n?{get:function(t){var e=c(this);if(mh(t)){var n=vh(t);return!0===n?Ah(e).get(t):n?n[e.id]:void 0}},set:function(t,e){return u(this,t,e)}}:{add:function(t){return u(this,t,!0)}}),o}};(function(t,e,n){var r=-1!==t.indexOf("Map"),o=-1!==t.indexOf("Weak"),i=r?"set":"add",c=Wp[t],u=c&&c.prototype,a=c,f={},s=function(t){var e=Hp(u[t]);qp(u,t,"add"===t?function(t){return e(this,0===t?0:t),this}:"delete"===t?function(t){return!(o&&!Qp(t))&&e(this,0===t?0:t)}:"get"===t?function(t){return o&&!Qp(t)?void 0:e(this,0===t?0:t)}:"has"===t?function(t){return!(o&&!Qp(t))&&e(this,0===t?0:t)}:function(t,n){return e(this,0===t?0:t,n),this})};if(Vp(t,!Yp(c)||!(o||u.forEach&&!Zp((function(){(new c).entries().next()})))))a=n.getConstructor(e,t,r,i),Jp.enable();else if(Vp(t,!0)){var l=new a,p=l[i](o?{}:-0,1)!==l,h=Zp((function(){l.has(1)})),v=th((function(t){new c(t)})),d=!o&&Zp((function(){for(var t=new c,e=5;e--;)t[i](e,e);return!t.has(-0)}));v||((a=e((function(t,e){Xp(t,u);var n=nh(new c,t,a);return $p(e)||Kp(e,n[i],{that:n,AS_ENTRIES:r}),n}))).prototype=u,u.constructor=a),(h||d)&&(s("delete"),s("has"),r&&s("get")),(d||p)&&s(i),o&&u.clear&&delete u.clear}f[t]=a,zp({global:!0,constructor:!0,forced:a!==c},f),eh(a,t),o||n.setStrong(a,t,r)})("WeakSet",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),xh);var Lh,Rh,kh,Mh=me("span").classList,Nh=Mh&&Mh.constructor&&Mh.constructor.prototype,_h=Nh===Object.prototype?void 0:Nh,Dh=c,Fh={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0},Bh=_h,Gh=_l,Uh=Xe,zh=Yi,Wh=oe("iterator"),Hh=Gh.values,Vh=function(t,e){if(t){if(t[Wh]!==Hh)try{Uh(t,Wh,Hh)}catch(e){t[Wh]=Hh}if(zh(t,e,!0),Fh[e])for(var n in Gh)if(t[n]!==Gh[n])try{Uh(t,n,Gh[n])}catch(e){t[n]=Gh[n]}}};for(var qh in Fh)Vh(Dh[qh]&&Dh[qh].prototype,qh);function Jh(t,e,n,r){if("a"===n&&!r)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof e?t!==e||!r:!e.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===n?r:"a"===n?r.call(t):r?r.value:e.get(t)}Vh(Bh,"DOMTokenList");var Kh="#ch-tooltip",Xh={enabled:!0,text:function(t,e,n){return"".concat(e," - ").concat(n.format("LLLL"))}},Yh={placement:"top",modifiers:[{name:"offset",options:{offset:[0,8]}}]},$h={getBoundingClientRect:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return{width:0,height:0,top:e,right:t,bottom:e,left:t,x:t,y:e,toJSON:function(){}}}},Qh=function(){function n(t){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,n),Lh.add(this),this.name="Tooltip",this.calendar=t,this.root=null,this.popperInstance=null,this.options=Xh,this.listenerAttached=!1}var r,o,i;return r=n,(o=[{key:"setup",value:function(e){this.options=Object.assign(Object.assign({},Xh),e);var n=this.calendar.eventEmitter;if(!this.options.enabled)return this.listenerAttached&&(n.off("mouseover",this.mouseOverCallback,this),n.off("mouseout",this.mouseOutCallback,this),this.listenerAttached=!1),void this.destroy();if(this.popperOptions=Object.assign(Object.assign({},Yh),this.options),this.root=document.getElementById(Kh.slice(1)),!this.root){var r=document.createElement("div");r.setAttribute("id",Kh.slice(1)),r.setAttribute("role","tooltip"),r.innerHTML='
')+''),this.root=document.body.appendChild(r)}this.root.setAttribute("data-theme",this.calendar.options.options.theme),this.popperInstance=t($h,this.root,this.popperOptions),this.listenerAttached||(n.on("mouseover",this.mouseOverCallback,this),n.on("mouseout",this.mouseOutCallback,this),this.listenerAttached=!0)}},{key:"mouseOverCallback",value:function(t,e,n){Jh(this,Lh,"m",Rh).call(this,t.target,e,n)}},{key:"mouseOutCallback",value:function(){Jh(this,Lh,"m",kh).call(this)}},{key:"paint",value:function(){return Promise.resolve()}},{key:"destroy",value:function(){return this.root&&this.root.remove(),Promise.resolve()}}])&&e(r.prototype,o),i&&e(r,i),Object.defineProperty(r,"prototype",{writable:!1}),n}();Lh=new WeakSet,Rh=function(t,e,r){var o=this,i=this.options.text,c=i?i(e,r,this.calendar.dateHelper.date(e)):null;c&&($h.getBoundingClientRect=function(){return t.getBoundingClientRect()},document.getElementById("".concat(Kh.slice(1),"-body")).innerHTML=c,this.popperInstance.setOptions((function(){return Object.assign(Object.assign({},o.popperOptions),{modifiers:[].concat(n(o.popperOptions.modifiers),[{name:"eventListeners",enabled:!0}])})})),this.popperInstance.update(),this.root.setAttribute("data-show","1"))},kh=function(){var t=this;this.root.removeAttribute("data-show"),this.popperInstance.setOptions((function(){return Object.assign(Object.assign({},t.popperOptions),{modifiers:[].concat(n(t.popperOptions.modifiers),[{name:"eventListeners",enabled:!1}])})}))};export{Qh as default};//# sourceMappingURL=Tooltip.min.esm.js.map diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.esm.js.map b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.esm.js.map new file mode 100644 index 0000000..449a4de --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.esm.js.map @@ -0,0 +1 @@ +{"version":3,"file":"Tooltip.min.esm.js","sources":["../../node_modules/core-js/internals/global.js","../../node_modules/core-js/internals/fails.js","../../node_modules/core-js/internals/descriptors.js","../../node_modules/core-js/internals/function-bind-native.js","../../node_modules/core-js/internals/function-call.js","../../node_modules/core-js/internals/object-property-is-enumerable.js","../../node_modules/core-js/internals/create-property-descriptor.js","../../node_modules/core-js/internals/engine-v8-version.js","../../node_modules/core-js/internals/function-uncurry-this.js","../../node_modules/core-js/internals/classof-raw.js","../../node_modules/core-js/internals/indexed-object.js","../../node_modules/core-js/internals/is-null-or-undefined.js","../../node_modules/core-js/internals/require-object-coercible.js","../../node_modules/core-js/internals/to-indexed-object.js","../../node_modules/core-js/internals/document-all.js","../../node_modules/core-js/internals/is-callable.js","../../node_modules/core-js/internals/is-object.js","../../node_modules/core-js/internals/get-built-in.js","../../node_modules/core-js/internals/object-is-prototype-of.js","../../node_modules/core-js/internals/engine-user-agent.js","../../node_modules/core-js/internals/symbol-constructor-detection.js","../../node_modules/core-js/internals/use-symbol-as-uid.js","../../node_modules/core-js/internals/is-symbol.js","../../node_modules/core-js/internals/try-to-string.js","../../node_modules/core-js/internals/a-callable.js","../../node_modules/core-js/internals/get-method.js","../../node_modules/core-js/internals/ordinary-to-primitive.js","../../node_modules/core-js/internals/define-global-property.js","../../node_modules/core-js/internals/shared-store.js","../../node_modules/core-js/internals/shared.js","../../node_modules/core-js/internals/to-object.js","../../node_modules/core-js/internals/has-own-property.js","../../node_modules/core-js/internals/uid.js","../../node_modules/core-js/internals/well-known-symbol.js","../../node_modules/core-js/internals/to-primitive.js","../../node_modules/core-js/internals/to-property-key.js","../../node_modules/core-js/internals/document-create-element.js","../../node_modules/core-js/internals/ie8-dom-define.js","../../node_modules/core-js/internals/object-get-own-property-descriptor.js","../../node_modules/core-js/internals/v8-prototype-define-bug.js","../../node_modules/core-js/internals/an-object.js","../../node_modules/core-js/internals/object-define-property.js","../../node_modules/core-js/internals/create-non-enumerable-property.js","../../node_modules/core-js/internals/function-name.js","../../node_modules/core-js/internals/inspect-source.js","../../node_modules/core-js/internals/internal-state.js","../../node_modules/core-js/internals/weak-map-basic-detection.js","../../node_modules/core-js/internals/shared-key.js","../../node_modules/core-js/internals/hidden-keys.js","../../node_modules/core-js/internals/make-built-in.js","../../node_modules/core-js/internals/define-built-in.js","../../node_modules/core-js/internals/math-trunc.js","../../node_modules/core-js/internals/to-integer-or-infinity.js","../../node_modules/core-js/internals/to-absolute-index.js","../../node_modules/core-js/internals/to-length.js","../../node_modules/core-js/internals/length-of-array-like.js","../../node_modules/core-js/internals/array-includes.js","../../node_modules/core-js/internals/object-keys-internal.js","../../node_modules/core-js/internals/enum-bug-keys.js","../../node_modules/core-js/internals/object-get-own-property-names.js","../../node_modules/core-js/internals/object-get-own-property-symbols.js","../../node_modules/core-js/internals/own-keys.js","../../node_modules/core-js/internals/copy-constructor-properties.js","../../node_modules/core-js/internals/is-forced.js","../../node_modules/core-js/internals/export.js","../../node_modules/core-js/internals/is-array.js","../../node_modules/core-js/internals/does-not-exceed-safe-integer.js","../../node_modules/core-js/internals/create-property.js","../../node_modules/core-js/internals/to-string-tag-support.js","../../node_modules/core-js/internals/classof.js","../../node_modules/core-js/internals/is-constructor.js","../../node_modules/core-js/internals/array-species-constructor.js","../../node_modules/core-js/internals/array-species-create.js","../../node_modules/core-js/internals/array-method-has-species-support.js","../../node_modules/core-js/modules/es.array.concat.js","../../node_modules/core-js/internals/define-built-in-accessor.js","../../node_modules/core-js/modules/es.function.name.js","../../node_modules/core-js/internals/object-keys.js","../../node_modules/core-js/internals/object-assign.js","../../node_modules/core-js/modules/es.object.assign.js","../../node_modules/core-js/internals/object-to-string.js","../../node_modules/core-js/modules/es.object.to-string.js","../../node_modules/core-js/internals/engine-is-node.js","../../node_modules/core-js/internals/task.js","../../node_modules/core-js/internals/function-uncurry-this-accessor.js","../../node_modules/core-js/internals/a-possible-prototype.js","../../node_modules/core-js/internals/object-set-prototype-of.js","../../node_modules/core-js/internals/set-to-string-tag.js","../../node_modules/core-js/internals/set-species.js","../../node_modules/core-js/internals/an-instance.js","../../node_modules/core-js/internals/a-constructor.js","../../node_modules/core-js/internals/species-constructor.js","../../node_modules/core-js/internals/function-apply.js","../../node_modules/core-js/internals/function-uncurry-this-clause.js","../../node_modules/core-js/internals/function-bind-context.js","../../node_modules/core-js/internals/html.js","../../node_modules/core-js/internals/array-slice.js","../../node_modules/core-js/internals/validate-arguments-length.js","../../node_modules/core-js/internals/engine-is-ios.js","../../node_modules/core-js/internals/queue.js","../../node_modules/core-js/internals/microtask.js","../../node_modules/core-js/internals/engine-is-ios-pebble.js","../../node_modules/core-js/internals/engine-is-webos-webkit.js","../../node_modules/core-js/internals/perform.js","../../node_modules/core-js/internals/promise-native-constructor.js","../../node_modules/core-js/internals/engine-is-deno.js","../../node_modules/core-js/internals/engine-is-browser.js","../../node_modules/core-js/internals/promise-constructor-detection.js","../../node_modules/core-js/internals/new-promise-capability.js","../../node_modules/core-js/modules/es.promise.constructor.js","../../node_modules/core-js/internals/host-report-errors.js","../../node_modules/core-js/internals/iterators.js","../../node_modules/core-js/internals/is-array-iterator-method.js","../../node_modules/core-js/internals/get-iterator-method.js","../../node_modules/core-js/internals/get-iterator.js","../../node_modules/core-js/internals/iterator-close.js","../../node_modules/core-js/internals/iterate.js","../../node_modules/core-js/internals/check-correctness-of-iteration.js","../../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","../../node_modules/core-js/modules/es.promise.all.js","../../node_modules/core-js/modules/es.promise.catch.js","../../node_modules/core-js/modules/es.promise.race.js","../../node_modules/core-js/modules/es.promise.reject.js","../../node_modules/core-js/internals/promise-resolve.js","../../node_modules/core-js/modules/es.promise.resolve.js","../../node_modules/core-js/internals/object-define-properties.js","../../node_modules/core-js/internals/object-create.js","../../node_modules/core-js/internals/add-to-unscopables.js","../../node_modules/core-js/internals/iterators-core.js","../../node_modules/core-js/internals/correct-prototype-getter.js","../../node_modules/core-js/internals/object-get-prototype-of.js","../../node_modules/core-js/internals/iterator-create-constructor.js","../../node_modules/core-js/internals/iterator-define.js","../../node_modules/core-js/internals/create-iter-result-object.js","../../node_modules/core-js/modules/es.array.iterator.js","../../node_modules/core-js/internals/to-string.js","../../node_modules/core-js/internals/string-multibyte.js","../../node_modules/core-js/modules/es.string.iterator.js","../../node_modules/core-js/internals/array-slice-simple.js","../../node_modules/core-js/internals/object-get-own-property-names-external.js","../../node_modules/core-js/internals/array-buffer-non-extensible.js","../../node_modules/core-js/internals/object-is-extensible.js","../../node_modules/core-js/internals/freezing.js","../../node_modules/core-js/internals/internal-metadata.js","../../node_modules/core-js/internals/inherit-if-required.js","../../node_modules/core-js/internals/collection.js","../../node_modules/core-js/internals/define-built-ins.js","../../node_modules/core-js/internals/array-iteration.js","../../node_modules/core-js/internals/collection-weak.js","../../node_modules/core-js/modules/es.weak-set.constructor.js","../../node_modules/core-js/internals/dom-iterables.js","../../node_modules/core-js/internals/dom-token-list-prototype.js","../../node_modules/core-js/modules/web.dom-collections.iterator.js","../../node_modules/tslib/tslib.es6.js","../../../src/plugins/Tooltip.ts"],"sourcesContent":["'use strict';\nvar check = function (it) {\n return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n check(typeof this == 'object' && this) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-function-prototype-bind -- safe\n var test = (function () { /* empty */ }).bind();\n // eslint-disable-next-line no-prototype-builtins -- safe\n return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nmodule.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n return function () {\n return call.apply(fn, arguments);\n };\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n return it === null || it === undefined;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n return it;\n};\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar documentAll = typeof document == 'object' && document.all;\n\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nvar IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;\n\nmodule.exports = {\n all: documentAll,\n IS_HTMLDDA: IS_HTMLDDA\n};\n","'use strict';\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = $documentAll.IS_HTMLDDA ? function (argument) {\n return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n return typeof argument == 'function';\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\nmodule.exports = $documentAll.IS_HTMLDDA ? function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;\n} : function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol('symbol detection');\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n // of course, fail.\n return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n try {\n return $String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.34.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',\n license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',\n source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name)) {\n WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n ? Symbol[name]\n : createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw new $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a !== 7;\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype !== 42;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n /* eslint-disable no-self-assign -- prototype methods protection */\n store.get = store.get;\n store.has = store.has;\n store.set = store.set;\n /* eslint-enable no-self-assign -- prototype methods protection */\n set = function (it, metadata) {\n if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n store.set(it, metadata);\n return metadata;\n };\n get = function (it) {\n return store.get(it) || {};\n };\n has = function (it) {\n return store.has(it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (options && options.getter) name = 'get ' + name;\n if (options && options.setter) name = 'set ' + name;\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n else value.name = name;\n }\n if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n defineProperty(value, 'length', { value: options.arity });\n }\n try {\n if (options && hasOwn(options, 'constructor') && options.constructor) {\n if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n } else if (value.prototype) value.prototype = undefined;\n } catch (error) { /* empty */ }\n var state = enforceInternalState(value);\n if (!hasOwn(state, 'source')) {\n state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- NaN check\n return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el !== el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value !== value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value === POLYFILL ? true\n : value === NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.dontCallGetSet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || defineGlobalProperty(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.dontCallGetSet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n defineBuiltIn(target, key, sourceProperty, options);\n }\n};\n","'use strict';\nvar classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n return classof(argument) === 'Array';\n};\n","'use strict';\nvar $TypeError = TypeError;\nvar MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991\n\nmodule.exports = function (it) {\n if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');\n return it;\n};\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n var propertyKey = toPropertyKey(key);\n if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n else object[propertyKey] = value;\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.test(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n }\n try {\n // we can't check .prototype since constructors produced by .bind haven't it\n // `Function#toString` throws on some built-it function in some legacy engines\n // (for example, `DOMQuad` and similar in FF41-)\n return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n } catch (error) {\n return true;\n }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","'use strict';\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n var C;\n if (isArray(originalArray)) {\n C = originalArray.constructor;\n // cross-realm fallback\n if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;\n else if (isObject(C)) {\n C = C[SPECIES];\n if (C === null) C = undefined;\n }\n } return C === undefined ? $Array : C;\n};\n","'use strict';\nvar arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (METHOD_NAME) {\n // We can't use this feature detection in V8 since it causes\n // deoptimization and serious performance degradation\n // https://github.com/zloirock/core-js/issues/677\n return V8_VERSION >= 51 || !fails(function () {\n var array = [];\n var constructor = array.constructor = {};\n constructor[SPECIES] = function () {\n return { foo: 1 };\n };\n return array[METHOD_NAME](Boolean).foo !== 1;\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar isArray = require('../internals/is-array');\nvar isObject = require('../internals/is-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');\nvar createProperty = require('../internals/create-property');\nvar arraySpeciesCreate = require('../internals/array-species-create');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');\n\n// We can't use this feature detection in V8 since it causes\n// deoptimization and serious performance degradation\n// https://github.com/zloirock/core-js/issues/679\nvar IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {\n var array = [];\n array[IS_CONCAT_SPREADABLE] = false;\n return array.concat()[0] !== array;\n});\n\nvar isConcatSpreadable = function (O) {\n if (!isObject(O)) return false;\n var spreadable = O[IS_CONCAT_SPREADABLE];\n return spreadable !== undefined ? !!spreadable : isArray(O);\n};\n\nvar FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat');\n\n// `Array.prototype.concat` method\n// https://tc39.es/ecma262/#sec-array.prototype.concat\n// with adding support of @@isConcatSpreadable and @@species\n$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n concat: function concat(arg) {\n var O = toObject(this);\n var A = arraySpeciesCreate(O, 0);\n var n = 0;\n var i, k, length, len, E;\n for (i = -1, length = arguments.length; i < length; i++) {\n E = i === -1 ? O : arguments[i];\n if (isConcatSpreadable(E)) {\n len = lengthOfArrayLike(E);\n doesNotExceedSafeInteger(n + len);\n for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);\n } else {\n doesNotExceedSafeInteger(n + 1);\n createProperty(A, n++, E);\n }\n }\n A.length = n;\n return A;\n }\n});\n","'use strict';\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineProperty = require('../internals/object-define-property');\n\nmodule.exports = function (target, name, descriptor) {\n if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });\n if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });\n return defineProperty.f(target, name, descriptor);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar FUNCTION_NAME_EXISTS = require('../internals/function-name').EXISTS;\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\n\nvar FunctionPrototype = Function.prototype;\nvar functionToString = uncurryThis(FunctionPrototype.toString);\nvar nameRE = /function\\b(?:\\s|\\/\\*[\\S\\s]*?\\*\\/|\\/\\/[^\\n\\r]*[\\n\\r]+)*([^\\s(/]*)/;\nvar regExpExec = uncurryThis(nameRE.exec);\nvar NAME = 'name';\n\n// Function instances `.name` property\n// https://tc39.es/ecma262/#sec-function-instances-name\nif (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {\n defineBuiltInAccessor(FunctionPrototype, NAME, {\n configurable: true,\n get: function () {\n try {\n return regExpExec(nameRE, functionToString(this))[1];\n } catch (error) {\n return '';\n }\n }\n });\n}\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol('assign detection');\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","'use strict';\nvar $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {\n assign: assign\n});\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar global = require('../internals/global');\nvar classof = require('../internals/classof-raw');\n\nmodule.exports = classof(global.process) === 'process';\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar $location, defer, channel, port;\n\nfails(function () {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n $location = global.location;\n});\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar eventListener = function (event) {\n run(event.data);\n};\n\nvar globalPostMessageDefer = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), $location.protocol + '//' + $location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(handler) {\n validateArgumentsLength(arguments.length, 1);\n var fn = isCallable(handler) ? handler : Function(handler);\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(fn, undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = eventListener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n $location && $location.protocol !== 'file:' &&\n !fails(globalPostMessageDefer)\n ) {\n defer = globalPostMessageDefer;\n global.addEventListener('message', eventListener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nmodule.exports = function (object, key, method) {\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));\n } catch (error) { /* empty */ }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw new $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","'use strict';\n/* eslint-disable no-proto -- safe */\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (target, TAG, STATIC) {\n if (target && !STATIC) target = target.prototype;\n if (target && !hasOwn(target, TO_STRING_TAG)) {\n defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineBuiltInAccessor(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw new $TypeError('Incorrect invocation');\n};\n","'use strict';\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a constructor');\n};\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","'use strict';\nvar classofRaw = require('../internals/classof-raw');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (fn) {\n // Nashorn bug:\n // https://github.com/zloirock/core-js/issues/1128\n // https://github.com/zloirock/core-js/issues/1130\n if (classofRaw(fn) === 'Function') return uncurryThis(fn);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","'use strict';\nvar $TypeError = TypeError;\n\nmodule.exports = function (passed, required) {\n if (passed < required) throw new $TypeError('Not enough arguments');\n return passed;\n};\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line redos/no-vulnerable -- safe\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","'use strict';\nvar Queue = function () {\n this.head = null;\n this.tail = null;\n};\n\nQueue.prototype = {\n add: function (item) {\n var entry = { item: item, next: null };\n var tail = this.tail;\n if (tail) tail.next = entry;\n else this.head = entry;\n this.tail = entry;\n },\n get: function () {\n var entry = this.head;\n if (entry) {\n var next = this.head = entry.next;\n if (next === null) this.tail = null;\n return entry.item;\n }\n }\n};\n\nmodule.exports = Queue;\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar Queue = require('../internals/queue');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar microtask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\nvar notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!microtask) {\n var queue = new Queue();\n\n var flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (fn = queue.get()) try {\n fn();\n } catch (error) {\n if (queue.head) notify();\n throw error;\n }\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessage\n // - onreadystatechange\n // - setTimeout\n } else {\n // `webpack` dev server bug on IE global methods - use bind(fn, global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n\n microtask = function (fn) {\n if (!queue.head) notify();\n queue.add(fn);\n };\n}\n\nmodule.exports = microtask;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","'use strict';\nvar global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n && typeof window == 'object'\n && typeof document == 'object';\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n // Detect correctness of subclassing with @@species support\n var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar $TypeError = TypeError;\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar IS_NODE = require('../internals/engine-is-node');\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar perform = require('../internals/perform');\nvar Queue = require('../internals/queue');\nvar InternalStateModule = require('../internals/internal-state');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar PromiseConstructorDetection = require('../internals/promise-constructor-detection');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\n\nvar PROMISE = 'Promise';\nvar FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;\nvar NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;\nvar NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar PromiseConstructor = NativePromiseConstructor;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar callReaction = function (reaction, state) {\n var value = state.value;\n var ok = state.state === FULFILLED;\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(new TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n microtask(function () {\n var reactions = state.reactions;\n var reaction;\n while (reaction = reactions.get()) {\n callReaction(reaction, state);\n }\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw new TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED_PROMISE_CONSTRUCTOR) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalPromiseState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n\n PromisePrototype = PromiseConstructor.prototype;\n\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: new Queue(),\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n state.parent = true;\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n if (state.state === PENDING) state.reactions.add(reaction);\n else microtask(function () {\n callReaction(reaction, state);\n });\n return reaction.promise;\n });\n\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalPromiseState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!NATIVE_PROMISE_SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n","'use strict';\nmodule.exports = function (a, b) {\n try {\n // eslint-disable-next-line no-console -- safe\n arguments.length === 1 ? console.error(a) : console.error(a, b);\n } catch (error) { /* empty */ }\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw new $TypeError(tryToString(argument) + ' is not iterable');\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_RECORD = !!(options && options.IS_RECORD);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_RECORD) {\n iterator = iterable.iterator;\n } else if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = IS_RECORD ? iterable.next : iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n try {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n } catch (error) { return false; } // workaround of old WebKit + `eval` bug\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.all` method\n// https://tc39.es/ecma262/#sec-promise.all\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar defineBuiltIn = require('../internals/define-built-in');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\n\n// `Promise.prototype.catch` method\n// https://tc39.es/ecma262/#sec-promise.prototype.catch\n$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n});\n\n// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromiseConstructor)) {\n var method = getBuiltIn('Promise').prototype['catch'];\n if (NativePromisePrototype['catch'] !== method) {\n defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.race` method\n// https://tc39.es/ecma262/#sec-promise.race\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\n// `Promise.reject` method\n// https://tc39.es/ecma262/#sec-promise.reject\n$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n reject: function reject(r) {\n var capability = newPromiseCapabilityModule.f(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar promiseResolve = require('../internals/promise-resolve');\n\nvar PromiseConstructorWrapper = getBuiltIn('Promise');\nvar CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;\n\n// `Promise.resolve` method\n// https://tc39.es/ecma262/#sec-promise.resolve\n$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {\n resolve: function resolve(x) {\n return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);\n }\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var props = toIndexedObject(Properties);\n var keys = objectKeys(Properties);\n var length = keys.length;\n var index = 0;\n var key;\n while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n return O;\n};\n","'use strict';\n/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n activeXDocument.write(scriptTag(''));\n activeXDocument.close();\n var temp = activeXDocument.parentWindow.Object;\n activeXDocument = null; // avoid memory leak\n return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = documentCreateElement('iframe');\n var JS = 'java' + SCRIPT + ':';\n var iframeDocument;\n iframe.style.display = 'none';\n html.appendChild(iframe);\n // https://github.com/zloirock/core-js/issues/475\n iframe.src = String(JS);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(scriptTag('document.F=Object'));\n iframeDocument.close();\n return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n try {\n activeXDocument = new ActiveXObject('htmlfile');\n } catch (error) { /* ignore */ }\n NullProtoObject = typeof document != 'undefined'\n ? document.domain && activeXDocument\n ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n : NullProtoObjectViaIFrame()\n : NullProtoObjectViaActiveX(activeXDocument); // WSH\n var length = enumBugKeys.length;\n while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n EmptyConstructor[PROTOTYPE] = anObject(O);\n result = new EmptyConstructor();\n EmptyConstructor[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = NullProtoObject();\n return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] === undefined) {\n defineProperty(ArrayPrototype, UNSCOPABLES, {\n configurable: true,\n value: create(null)\n });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n arrayIterator = [].keys();\n // Safari 8 has buggy iterators w/o `next`\n if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n else {\n PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {\n var test = {};\n // FF44- legacy iterators case\n return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n defineBuiltIn(IteratorPrototype, ITERATOR, function () {\n return this;\n });\n}\n\nmodule.exports = {\n IteratorPrototype: IteratorPrototype,\n BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n function F() { /* empty */ }\n F.prototype.constructor = null;\n // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar $Object = Object;\nvar ObjectPrototype = $Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n// eslint-disable-next-line es/no-object-getprototypeof -- safe\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {\n var object = toObject(O);\n if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n var constructor = object.constructor;\n if (isCallable(constructor) && object instanceof constructor) {\n return constructor.prototype;\n } return object instanceof $Object ? ObjectPrototype : null;\n};\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {\n var TO_STRING_TAG = NAME + ' Iterator';\n IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });\n setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n Iterators[TO_STRING_TAG] = returnThis;\n return IteratorConstructor;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/iterator-create-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n createIteratorConstructor(IteratorConstructor, NAME, next);\n\n var getIterationMethod = function (KIND) {\n if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];\n\n switch (KIND) {\n case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n }\n\n return function () { return new IteratorConstructor(this); };\n };\n\n var TO_STRING_TAG = NAME + ' Iterator';\n var INCORRECT_VALUES_NAME = false;\n var IterablePrototype = Iterable.prototype;\n var nativeIterator = IterablePrototype[ITERATOR]\n || IterablePrototype['@@iterator']\n || DEFAULT && IterablePrototype[DEFAULT];\n var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n var CurrentIteratorPrototype, methods, KEY;\n\n // fix native\n if (anyNativeIterator) {\n CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n if (setPrototypeOf) {\n setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);\n }\n }\n // Set @@toStringTag to native iterators\n setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n }\n }\n\n // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n } else {\n INCORRECT_VALUES_NAME = true;\n defaultIterator = function values() { return call(nativeIterator, this); };\n }\n }\n\n // export additional methods\n if (DEFAULT) {\n methods = {\n values: getIterationMethod(VALUES),\n keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n entries: getIterationMethod(ENTRIES)\n };\n if (FORCED) for (KEY in methods) {\n if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n defineBuiltIn(IterablePrototype, KEY, methods[KEY]);\n }\n } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n }\n\n // define iterator\n if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n }\n Iterators[NAME] = defaultIterator;\n\n return methods;\n};\n","'use strict';\n// `CreateIterResultObject` abstract operation\n// https://tc39.es/ecma262/#sec-createiterresultobject\nmodule.exports = function (value, done) {\n return { value: value, done: done };\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineProperty = require('../internals/object-define-property').f;\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar IS_PURE = require('../internals/is-pure');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n setInternalState(this, {\n type: ARRAY_ITERATOR,\n target: toIndexedObject(iterated), // target\n index: 0, // next index\n kind: kind // kind\n });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n var state = getInternalState(this);\n var target = state.target;\n var index = state.index++;\n if (!target || index >= target.length) {\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n switch (state.kind) {\n case 'keys': return createIterResultObject(index, false);\n case 'values': return createIterResultObject(target[index], false);\n } return createIterResultObject([index, target[index]], false);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nvar values = Iterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n// V8 ~ Chrome 45- bug\nif (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {\n defineProperty(values, 'name', { value: 'values' });\n} catch (error) { /* empty */ }\n","'use strict';\nvar classof = require('../internals/classof');\n\nvar $String = String;\n\nmodule.exports = function (argument) {\n if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n return $String(argument);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n return function ($this, pos) {\n var S = toString(requireObjectCoercible($this));\n var position = toIntegerOrInfinity(pos);\n var size = S.length;\n var first, second;\n if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n first = charCodeAt(S, position);\n return first < 0xD800 || first > 0xDBFF || position + 1 === size\n || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n ? CONVERT_TO_STRING\n ? charAt(S, position)\n : first\n : CONVERT_TO_STRING\n ? stringSlice(S, position, position + 2)\n : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n };\n};\n\nmodule.exports = {\n // `String.prototype.codePointAt` method\n // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n codeAt: createMethod(false),\n // `String.prototype.at` method\n // https://github.com/mathiasbynens/String.prototype.at\n charAt: createMethod(true)\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n setInternalState(this, {\n type: STRING_ITERATOR,\n string: toString(iterated),\n index: 0\n });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n var state = getInternalState(this);\n var string = state.string;\n var index = state.index;\n var point;\n if (index >= string.length) return createIterResultObject(undefined, true);\n point = charAt(string, index);\n state.index += point.length;\n return createIterResultObject(point, false);\n});\n","'use strict';\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\n\nvar $Array = Array;\nvar max = Math.max;\n\nmodule.exports = function (O, start, end) {\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n var result = $Array(max(fin - k, 0));\n var n = 0;\n for (; k < fin; k++, n++) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n};\n","'use strict';\n/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n try {\n return $getOwnPropertyNames(it);\n } catch (error) {\n return arraySlice(windowNames);\n }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n return windowNames && classof(it) === 'Window'\n ? getWindowNames(it)\n : $getOwnPropertyNames(toIndexedObject(it));\n};\n","'use strict';\n// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it\nvar fails = require('../internals/fails');\n\nmodule.exports = fails(function () {\n if (typeof ArrayBuffer == 'function') {\n var buffer = new ArrayBuffer(8);\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe\n if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar ARRAY_BUFFER_NON_EXTENSIBLE = require('../internals/array-buffer-non-extensible');\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar $isExtensible = Object.isExtensible;\nvar FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); });\n\n// `Object.isExtensible` method\n// https://tc39.es/ecma262/#sec-object.isextensible\nmodule.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) {\n if (!isObject(it)) return false;\n if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false;\n return $isExtensible ? $isExtensible(it) : true;\n} : $isExtensible;\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n return Object.isExtensible(Object.preventExtensions({}));\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar isExtensible = require('../internals/object-is-extensible');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar setMetadata = function (it) {\n defineProperty(it, METADATA, { value: {\n objectID: 'O' + id++, // object ID\n weakData: {} // weak collections IDs\n } });\n};\n\nvar fastKey = function (it, create) {\n // return a primitive with prefix\n if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return 'F';\n // not necessary to add metadata\n if (!create) return 'E';\n // add missing metadata\n setMetadata(it);\n // return object ID\n } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return true;\n // not necessary to add metadata\n if (!create) return false;\n // add missing metadata\n setMetadata(it);\n // return the store of weak collections IDs\n } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n return it;\n};\n\nvar enable = function () {\n meta.enable = function () { /* empty */ };\n REQUIRED = true;\n var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n var splice = uncurryThis([].splice);\n var test = {};\n test[METADATA] = 1;\n\n // prevent exposing of metadata key\n if (getOwnPropertyNames(test).length) {\n getOwnPropertyNamesModule.f = function (it) {\n var result = getOwnPropertyNames(it);\n for (var i = 0, length = result.length; i < length; i++) {\n if (result[i] === METADATA) {\n splice(result, i, 1);\n break;\n }\n } return result;\n };\n\n $({ target: 'Object', stat: true, forced: true }, {\n getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n });\n }\n};\n\nvar meta = module.exports = {\n enable: enable,\n fastKey: fastKey,\n getWeakData: getWeakData,\n onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n var NewTarget, NewTargetPrototype;\n if (\n // it can work only with native `setPrototypeOf`\n setPrototypeOf &&\n // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n isCallable(NewTarget = dummy.constructor) &&\n NewTarget !== Wrapper &&\n isObject(NewTargetPrototype = NewTarget.prototype) &&\n NewTargetPrototype !== Wrapper.prototype\n ) setPrototypeOf($this, NewTargetPrototype);\n return $this;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n var ADDER = IS_MAP ? 'set' : 'add';\n var NativeConstructor = global[CONSTRUCTOR_NAME];\n var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n var Constructor = NativeConstructor;\n var exported = {};\n\n var fixMethod = function (KEY) {\n var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n defineBuiltIn(NativePrototype, KEY,\n KEY === 'add' ? function add(value) {\n uncurriedNativeMethod(this, value === 0 ? 0 : value);\n return this;\n } : KEY === 'delete' ? function (key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'get' ? function get(key) {\n return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'has' ? function has(key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : function set(key, value) {\n uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n return this;\n }\n );\n };\n\n var REPLACE = isForced(\n CONSTRUCTOR_NAME,\n !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n new NativeConstructor().entries().next();\n }))\n );\n\n if (REPLACE) {\n // create collection constructor\n Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n InternalMetadataModule.enable();\n } else if (isForced(CONSTRUCTOR_NAME, true)) {\n var instance = new Constructor();\n // early implementations not supports chaining\n var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance;\n // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n // most early implementations doesn't supports iterables, most modern - not close it correctly\n // eslint-disable-next-line no-new -- required for testing\n var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n // for early implementations -0 and +0 not the same\n var BUGGY_ZERO = !IS_WEAK && fails(function () {\n // V8 ~ Chromium 42- fails only with 5+ elements\n var $instance = new NativeConstructor();\n var index = 5;\n while (index--) $instance[ADDER](index, index);\n return !$instance.has(-0);\n });\n\n if (!ACCEPT_ITERABLES) {\n Constructor = wrapper(function (dummy, iterable) {\n anInstance(dummy, NativePrototype);\n var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n return that;\n });\n Constructor.prototype = NativePrototype;\n NativePrototype.constructor = Constructor;\n }\n\n if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n fixMethod('delete');\n fixMethod('has');\n IS_MAP && fixMethod('get');\n }\n\n if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n // weak collections should not contains .clear method\n if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n }\n\n exported[CONSTRUCTOR_NAME] = Constructor;\n $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported);\n\n setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n return Constructor;\n};\n","'use strict';\nvar defineBuiltIn = require('../internals/define-built-in');\n\nmodule.exports = function (target, src, options) {\n for (var key in src) defineBuiltIn(target, key, src[key], options);\n return target;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n var IS_MAP = TYPE === 1;\n var IS_FILTER = TYPE === 2;\n var IS_SOME = TYPE === 3;\n var IS_EVERY = TYPE === 4;\n var IS_FIND_INDEX = TYPE === 6;\n var IS_FILTER_REJECT = TYPE === 7;\n var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;\n return function ($this, callbackfn, that, specificCreate) {\n var O = toObject($this);\n var self = IndexedObject(O);\n var length = lengthOfArrayLike(self);\n var boundFunction = bind(callbackfn, that);\n var index = 0;\n var create = specificCreate || arraySpeciesCreate;\n var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n var value, result;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n value = self[index];\n result = boundFunction(value, index, O);\n if (TYPE) {\n if (IS_MAP) target[index] = result; // map\n else if (result) switch (TYPE) {\n case 3: return true; // some\n case 5: return value; // find\n case 6: return index; // findIndex\n case 2: push(target, value); // filter\n } else switch (TYPE) {\n case 4: return false; // every\n case 7: push(target, value); // filterReject\n }\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.forEach` method\n // https://tc39.es/ecma262/#sec-array.prototype.foreach\n forEach: createMethod(0),\n // `Array.prototype.map` method\n // https://tc39.es/ecma262/#sec-array.prototype.map\n map: createMethod(1),\n // `Array.prototype.filter` method\n // https://tc39.es/ecma262/#sec-array.prototype.filter\n filter: createMethod(2),\n // `Array.prototype.some` method\n // https://tc39.es/ecma262/#sec-array.prototype.some\n some: createMethod(3),\n // `Array.prototype.every` method\n // https://tc39.es/ecma262/#sec-array.prototype.every\n every: createMethod(4),\n // `Array.prototype.find` method\n // https://tc39.es/ecma262/#sec-array.prototype.find\n find: createMethod(5),\n // `Array.prototype.findIndex` method\n // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n findIndex: createMethod(6),\n // `Array.prototype.filterReject` method\n // https://github.com/tc39/proposal-array-filtering\n filterReject: createMethod(7)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar getWeakData = require('../internals/internal-metadata').getWeakData;\nvar anInstance = require('../internals/an-instance');\nvar anObject = require('../internals/an-object');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar iterate = require('../internals/iterate');\nvar ArrayIterationModule = require('../internals/array-iteration');\nvar hasOwn = require('../internals/has-own-property');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\nvar find = ArrayIterationModule.find;\nvar findIndex = ArrayIterationModule.findIndex;\nvar splice = uncurryThis([].splice);\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (state) {\n return state.frozen || (state.frozen = new UncaughtFrozenStore());\n};\n\nvar UncaughtFrozenStore = function () {\n this.entries = [];\n};\n\nvar findUncaughtFrozen = function (store, key) {\n return find(store.entries, function (it) {\n return it[0] === key;\n });\n};\n\nUncaughtFrozenStore.prototype = {\n get: function (key) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) return entry[1];\n },\n has: function (key) {\n return !!findUncaughtFrozen(this, key);\n },\n set: function (key, value) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) entry[1] = value;\n else this.entries.push([key, value]);\n },\n 'delete': function (key) {\n var index = findIndex(this.entries, function (it) {\n return it[0] === key;\n });\n if (~index) splice(this.entries, index, 1);\n return !!~index;\n }\n};\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n id: id++,\n frozen: undefined\n });\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var data = getWeakData(anObject(key), true);\n if (data === true) uncaughtFrozenStore(state).set(key, value);\n else data[state.id] = value;\n return that;\n };\n\n defineBuiltIns(Prototype, {\n // `{ WeakMap, WeakSet }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.delete\n // https://tc39.es/ecma262/#sec-weakset.prototype.delete\n 'delete': function (key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state)['delete'](key);\n return data && hasOwn(data, state.id) && delete data[state.id];\n },\n // `{ WeakMap, WeakSet }.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.has\n // https://tc39.es/ecma262/#sec-weakset.prototype.has\n has: function has(key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).has(key);\n return data && hasOwn(data, state.id);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `WeakMap.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.get\n get: function get(key) {\n var state = getInternalState(this);\n if (isObject(key)) {\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).get(key);\n return data ? data[state.id] : undefined;\n }\n },\n // `WeakMap.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.set\n set: function set(key, value) {\n return define(this, key, value);\n }\n } : {\n // `WeakSet.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-weakset.prototype.add\n add: function add(value) {\n return define(this, value, true);\n }\n });\n\n return Constructor;\n }\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionWeak = require('../internals/collection-weak');\n\n// `WeakSet` constructor\n// https://tc39.es/ecma262/#sec-weakset-constructor\ncollection('WeakSet', function (init) {\n return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionWeak);\n","'use strict';\n// iterable DOM collections\n// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods\nmodule.exports = {\n CSSRuleList: 0,\n CSSStyleDeclaration: 0,\n CSSValueList: 0,\n ClientRectList: 0,\n DOMRectList: 0,\n DOMStringList: 0,\n DOMTokenList: 1,\n DataTransferItemList: 0,\n FileList: 0,\n HTMLAllCollection: 0,\n HTMLCollection: 0,\n HTMLFormElement: 0,\n HTMLSelectElement: 0,\n MediaList: 0,\n MimeTypeArray: 0,\n NamedNodeMap: 0,\n NodeList: 1,\n PaintRequestList: 0,\n Plugin: 0,\n PluginArray: 0,\n SVGLengthList: 0,\n SVGNumberList: 0,\n SVGPathSegList: 0,\n SVGPointList: 0,\n SVGStringList: 0,\n SVGTransformList: 0,\n SourceBufferList: 0,\n StyleSheetList: 0,\n TextTrackCueList: 0,\n TextTrackList: 0,\n TouchList: 0\n};\n","'use strict';\n// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`\nvar documentCreateElement = require('../internals/document-create-element');\n\nvar classList = documentCreateElement('span').classList;\nvar DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;\n\nmodule.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nvar handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {\n if (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n } catch (error) {\n CollectionPrototype[ITERATOR] = ArrayValues;\n }\n setToStringTag(CollectionPrototype, COLLECTION_NAME, true);\n if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n } catch (error) {\n CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n }\n }\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);\n}\n\nhandlePrototype(DOMTokenListPrototype, 'DOMTokenList');\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n var _, done = false;\r\n for (var i = decorators.length - 1; i >= 0; i--) {\r\n var context = {};\r\n for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n if (kind === \"accessor\") {\r\n if (result === void 0) continue;\r\n if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n if (_ = accept(result.get)) descriptor.get = _;\r\n if (_ = accept(result.set)) descriptor.set = _;\r\n if (_ = accept(result.init)) initializers.unshift(_);\r\n }\r\n else if (_ = accept(result)) {\r\n if (kind === \"field\") initializers.unshift(_);\r\n else descriptor[key] = _;\r\n }\r\n }\r\n if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n var useValue = arguments.length > 2;\r\n for (var i = 0; i < initializers.length; i++) {\r\n value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n }\r\n return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n 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;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n var desc = Object.getOwnPropertyDescriptor(m, k);\r\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n desc = { enumerable: true, get: function() { return m[k]; } };\r\n }\r\n Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport default {\r\n __extends,\r\n __assign,\r\n __rest,\r\n __decorate,\r\n __param,\r\n __metadata,\r\n __awaiter,\r\n __generator,\r\n __createBinding,\r\n __exportStar,\r\n __values,\r\n __read,\r\n __spread,\r\n __spreadArrays,\r\n __spreadArray,\r\n __await,\r\n __asyncGenerator,\r\n __asyncDelegator,\r\n __asyncValues,\r\n __makeTemplateObject,\r\n __importStar,\r\n __importDefault,\r\n __classPrivateFieldGet,\r\n __classPrivateFieldSet,\r\n __classPrivateFieldIn,\r\n};\r\n","import { createPopper } from '@popperjs/core';\n\nimport type dayjs from 'dayjs';\nimport type { VirtualElement, StrictModifiers } from '@popperjs/core';\nimport type CalHeatmap from '../CalHeatmap';\nimport type { IPlugin, PluginOptions, Timestamp } from '../index';\n\nconst DEFAULT_SELECTOR = '#ch-tooltip';\n\ninterface PopperOptions {\n placement: any;\n modifiers: any[];\n strategy: any;\n onFirstUpdate?: any;\n}\n\ninterface TooltipOptions extends PluginOptions, PopperOptions {\n enabled: boolean;\n text: (timestamp: Timestamp, value: number, dayjsDate: dayjs.Dayjs) => string;\n}\n\nconst defaultOptions: Partial = {\n enabled: true,\n\n // Expecting a function, which will return the tooltip content\n text: (_timestamp, value, dayjsDate): string =>\n // eslint-disable-next-line implicit-arrow-linebreak\n `${value} - ${dayjsDate.format('LLLL')}`,\n};\n\nconst DEFAULT_POPPER_OPTIONS = {\n placement: 'top',\n modifiers: [\n {\n name: 'offset',\n options: {\n offset: [0, 8],\n },\n },\n ],\n};\n\nconst virtualElement: VirtualElement = {\n getBoundingClientRect(x = 0, y = 0): DOMRect {\n return {\n width: 0,\n height: 0,\n top: y,\n right: x,\n bottom: y,\n left: x,\n x,\n y,\n toJSON: () => {},\n };\n },\n};\n\nexport default class Tooltip implements IPlugin {\n name = 'Tooltip';\n\n calendar: CalHeatmap;\n\n root: HTMLElement | null;\n\n popperInstance: any;\n\n popperOptions: any;\n\n options: Partial;\n\n listenerAttached: boolean;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.root = null;\n this.popperInstance = null;\n this.options = defaultOptions;\n this.listenerAttached = false;\n }\n\n setup(pluginOptions?: Partial): void {\n this.options = { ...defaultOptions, ...pluginOptions };\n const event = this.calendar.eventEmitter;\n\n if (!this.options.enabled) {\n if (this.listenerAttached) {\n event.off('mouseover', this.mouseOverCallback, this);\n event.off('mouseout', this.mouseOutCallback, this);\n\n this.listenerAttached = false;\n }\n\n this.destroy();\n return;\n }\n\n this.popperOptions = { ...DEFAULT_POPPER_OPTIONS, ...this.options };\n\n this.root = document.getElementById(DEFAULT_SELECTOR.slice(1));\n\n if (!this.root) {\n const tooltipElem = document.createElement('div');\n tooltipElem.setAttribute('id', DEFAULT_SELECTOR.slice(1));\n tooltipElem.setAttribute('role', 'tooltip');\n tooltipElem.innerHTML =\n `
` +\n ``;\n\n this.root = document.body.appendChild(tooltipElem);\n }\n\n this.root.setAttribute('data-theme', this.calendar.options.options.theme);\n\n this.popperInstance = createPopper(\n virtualElement,\n this.root,\n this.popperOptions,\n );\n\n if (!this.listenerAttached) {\n event.on('mouseover', this.mouseOverCallback, this);\n event.on('mouseout', this.mouseOutCallback, this);\n this.listenerAttached = true;\n }\n }\n\n mouseOverCallback(e: PointerEvent, timestamp: Timestamp, value: number) {\n this.#show(e.target, timestamp, value);\n }\n\n mouseOutCallback() {\n this.#hide();\n }\n\n // eslint-disable-next-line class-methods-use-this\n paint(): Promise {\n return Promise.resolve();\n }\n\n destroy(): Promise {\n if (this.root) {\n this.root.remove();\n }\n\n return Promise.resolve();\n }\n\n #show(e: any, timestamp: Timestamp, value: number): void {\n const formatter = this.options.text;\n const title = formatter ?\n formatter(timestamp, value, this.calendar.dateHelper.date(timestamp)) :\n null;\n\n if (!title) {\n return;\n }\n\n virtualElement.getBoundingClientRect = () => e.getBoundingClientRect();\n document.getElementById(`${DEFAULT_SELECTOR.slice(1)}-body`)!.innerHTML =\n title;\n\n this.popperInstance.setOptions(() => ({\n ...this.popperOptions,\n modifiers: [\n ...this.popperOptions.modifiers,\n { name: 'eventListeners', enabled: true },\n ],\n }));\n\n this.popperInstance.update();\n\n this.root!.setAttribute('data-show', '1');\n }\n\n #hide(): void {\n this.root!.removeAttribute('data-show');\n\n this.popperInstance.setOptions(() => ({\n ...this.popperOptions,\n modifiers: [\n ...this.popperOptions.modifiers,\n { name: 'eventListeners', enabled: false },\n ],\n }));\n }\n}\n"],"names":["commonjsGlobal","globalThis","window","global","self","check","it","Math","this","Function","fails","exec","error","descriptors","require$$0","Object","defineProperty","get","functionBindNative","test","bind","hasOwnProperty","NATIVE_BIND","call","prototype","functionCall","apply","arguments","$propertyIsEnumerable","propertyIsEnumerable","getOwnPropertyDescriptor","NASHORN_BUG","objectPropertyIsEnumerable","f","V","descriptor","enumerable","match","version","createPropertyDescriptor","bitmap","value","configurable","writable","FunctionPrototype","uncurryThisWithBind","functionUncurryThis","fn","uncurryThis","toString","stringSlice","slice","classofRaw","require$$1","classof","require$$2","$Object","split","indexedObject","isNullOrUndefined","$TypeError","TypeError","requireObjectCoercible","IndexedObject","toIndexedObject","documentAll","document","all","documentAll_1","IS_HTMLDDA","undefined","isCallable","argument","isObject","getBuiltIn","namespace","method","length","objectIsPrototypeOf","isPrototypeOf","engineUserAgent","navigator","String","userAgent","process","Deno","versions","v8","engineV8Version","V8_VERSION","$String","symbolConstructorDetection","getOwnPropertySymbols","symbol","Symbol","sham","useSymbolAsUid","iterator","isSymbol","require$$3","$Symbol","tryToString","aCallable","getMethod","P","func","shared$3","exports","defineGlobalProperty","key","SHARED","sharedStore","store","sharedModule","push","mode","copyright","license","source","toObject","hasOwnProperty_1","hasOwn","id","postfix","random","uid","shared","NATIVE_SYMBOL","require$$4","USE_SYMBOL_AS_UID","require$$5","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","wellKnownSymbol","name","ordinaryToPrimitive","input","pref","val","valueOf","TO_PRIMITIVE","toPrimitive","result","exoticToPrim","toPropertyKey","EXISTS","createElement","documentCreateElement","ie8DomDefine","a","DESCRIPTORS","propertyIsEnumerableModule","require$$6","IE8_DOM_DEFINE","require$$7","$getOwnPropertyDescriptor","objectGetOwnPropertyDescriptor","O","objectDefineProperty","v8PrototypeDefineBug","anObject","V8_PROTOTYPE_DEFINE_BUG","$defineProperty","ENUMERABLE","CONFIGURABLE","WRITABLE","Attributes","current","definePropertyModule","createNonEnumerableProperty","object","makeBuiltIn$3","getDescriptor","functionName","PROPER","functionToString","inspectSource","set","has","WeakMap","weakMapBasicDetection","keys","sharedKey","hiddenKeys","NATIVE_WEAK_MAP","OBJECT_ALREADY_INITIALIZED","state","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","CONFIGURABLE_FUNCTION_NAME","enforceInternalState","getInternalState","replace","join","CONFIGURABLE_LENGTH","TEMPLATE","makeBuiltIn","makeBuiltInModule","options","getter","setter","arity","constructor","defineBuiltIn","simple","unsafe","nonConfigurable","nonWritable","ceil","floor","trunc","x","n","toIntegerOrInfinity","number","max","min","toAbsoluteIndex","index","integer","toLength","lengthOfArrayLike","obj","createMethod","IS_INCLUDES","$this","el","fromIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","i","enumBugKeys","internalObjectKeys","concat","objectGetOwnPropertyNames","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","ownKeys","getOwnPropertyDescriptorModule","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","toLowerCase","isForced_1","copyConstructorProperties","target","exceptions","_export","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","isArray","Array","createProperty","propertyKey","toStringTagSupport","TO_STRING_TAG_SUPPORT","TO_STRING_TAG","CORRECT_ARGUMENTS","tag","tryGet","callee","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","isConstructor","called","SPECIES","$Array","arraySpeciesConstructor","originalArray","C","arraySpeciesCreate","$","doesNotExceedSafeInteger","require$$8","arrayMethodHasSpeciesSupport","METHOD_NAME","array","foo","Boolean","require$$11","IS_CONCAT_SPREADABLE","require$$10","IS_CONCAT_SPREADABLE_SUPPORT","isConcatSpreadable","spreadable","proto","arg","k","len","E","A","defineBuiltInAccessor","FUNCTION_NAME_EXISTS","nameRE","regExpExec","objectKeys","$assign","assign","objectAssign","b","B","alphabet","forEach","chr","T","argumentsLength","S","j","$location","defer","channel","port","engineIsNode","uncurryThisAccessor","aPossiblePrototype","objectSetPrototypeOf","setPrototypeOf","CORRECT_SETTER","__proto__","setToStringTag","TAG","anInstance","Prototype","aConstructor","functionApply","Reflect","functionBindContext","that","html","arraySlice","engineIsIos","validateArgumentsLength","passed","required","IS_IOS","IS_NODE","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","location","run","runner","eventListener","event","globalPostMessageDefer","postMessage","protocol","host","handler","args","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","task","Queue","head","tail","add","item","entry","next","notify","toggle","node","promise","then","engineIsIosPebble","Pebble","engineIsWebosWebkit","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","Promise","queueMicrotaskDescriptor","microtask","flush","parent","domain","exit","enter","resolve","createTextNode","observe","characterData","microtask_1","perform","promiseNativeConstructor","engineIsDeno","engineIsBrowser","NativePromiseConstructor","IS_BROWSER","IS_DENO","require$$9","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","promiseConstructorDetection","CONSTRUCTOR","REJECTION_EVENT","newPromiseCapability$2","PromiseCapability","reject","$$resolve","$$reject","newPromiseCapability","Internal","OwnPromiseCapability","nativeThen","setSpecies","CONSTRUCTOR_NAME","Constructor","require$$12","speciesConstructor","defaultConstructor","require$$14","require$$15","hostReportErrors","console","require$$17","require$$18","InternalStateModule","require$$19","require$$20","newPromiseCapabilityModule","require$$22","PROMISE","require$$21","NATIVE_PROMISE_SUBCLASSING","getInternalPromiseState","setInternalState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","isThenable","callReaction","reaction","exited","ok","fail","rejection","onHandleUnhandled","isReject","notified","reactions","onUnhandled","reason","initEvent","isUnhandled","emit","unwrap","internalReject","done","internalResolve","wrapper","executor","onFulfilled","onRejected","PromiseWrapper","wrap","iterators","Iterators","ITERATOR","ArrayPrototype","getIteratorMethod","isArrayIteratorMethod","getIterator","usingIterator","iteratorMethod","iteratorClose","kind","innerResult","innerError","Result","stopped","ResultPrototype","iterate","iterable","unboundFunction","iterFn","step","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","SAFE_CLOSING","iteratorWithReturn","return","from","checkCorrectnessOfIteration","SKIP_CLOSING","ITERATION_SUPPORT","promiseStaticsIncorrectIteration","capability","$promiseResolve","values","remaining","alreadyCalled","real","catch","race","r","promiseResolve","promiseCapability","objectDefineProperties","defineProperties","Properties","props","activeXDocument","definePropertiesModule","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","style","display","src","contentWindow","open","F","objectCreate","create","UNSCOPABLES","IteratorPrototype","PrototypeOfArrayIteratorPrototype","arrayIterator","correctPrototypeGetter","getPrototypeOf","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","objectGetPrototypeOf","BUGGY_SAFARI_ITERATORS","NEW_ITERATOR_PROTOTYPE","iteratorsCore","returnThis","createIteratorConstructor","IteratorConstructor","NAME","ENUMERABLE_NEXT","PROPER_FUNCTION_NAME","require$$13","KEYS","VALUES","ENTRIES","iteratorDefine","Iterable","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","createIterResultObject","addToUnscopables","defineIterator","ARRAY_ITERATOR","es_array_iterator","iterated","Arguments","charAt","charCodeAt","CONVERT_TO_STRING","pos","first","second","position","size","codeAt","STRING_ITERATOR","point","internalMetadata","objectGetOwnPropertyNamesExternal","$getOwnPropertyNames","start","end","fin","windowNames","getWindowNames","arrayBufferNonExtensible","ArrayBuffer","buffer","isExtensible","ARRAY_BUFFER_NON_EXTENSIBLE","$isExtensible","objectIsExtensible","freezing","preventExtensions","getOwnPropertyNamesExternalModule","FREEZING","REQUIRED","METADATA","setMetadata","objectID","weakData","meta","internalMetadataModule","enable","splice","fastKey","getWeakData","onFreeze","InternalMetadataModule","inheritIfRequired","dummy","Wrapper","NewTarget","NewTargetPrototype","IS_MAP","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_REJECT","NO_HOLES","callbackfn","specificCreate","boundFunction","arrayIteration","map","filter","some","every","find","findIndex","filterReject","defineBuiltIns","internalStateGetterFor","uncaughtFrozenStore","frozen","UncaughtFrozenStore","findUncaughtFrozen","delete","collectionWeak","getConstructor","ADDER","define","common","IS_WEAK","NativeConstructor","NativePrototype","exported","fixMethod","uncurriedNativeMethod","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","setStrong","collection","init","classList","DOMTokenListPrototype","domTokenListPrototype","DOMIterables","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DOMTokenList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","ArrayIteratorMethods","ArrayValues","handlePrototype","CollectionPrototype","COLLECTION_NAME","__classPrivateFieldGet","receiver","DEFAULT_SELECTOR","defaultOptions","enabled","text","_timestamp","dayjsDate","format","DEFAULT_POPPER_OPTIONS","placement","modifiers","offset","virtualElement","getBoundingClientRect","y","width","height","top","right","bottom","left","toJSON","Tooltip","calendar","_classCallCheck","root","popperInstance","listenerAttached","pluginOptions","eventEmitter","off","mouseOverCallback","mouseOutCallback","destroy","popperOptions","getElementById","tooltipElem","setAttribute","innerHTML","body","theme","createPopper","on","e","timestamp","_Tooltip_instances","_Tooltip_show","_Tooltip_hide","remove","_this","formatter","title","dateHelper","date","setOptions","_toConsumableArray","update","_this2","removeAttribute"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153]} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.js b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.js new file mode 100644 index 0000000..91d17ee --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.js @@ -0,0 +1 @@ +!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?module.exports=e(require("@popperjs/core")):"function"==typeof define&&define.amd?define(["@popperjs/core"],e):(t="undefined"!=typeof globalThis?globalThis:t||self).Tooltip=e(t.Popper)}(this,(function(t){"use strict";function e(t,e){for(var n=0;nt.length)&&(e=t.length);for(var n=0,r=new Array(e);n0&&g[0]<4?1:+(g[0]+g[1])),!m&&et&&(!(g=et.match(/Edge\/(\d+)/))||g[1]>=74)&&(g=et.match(/Chrome\/(\d+)/))&&(m=+g[1]);var ct=m,ut=ct,at=a,ft=c.String,st=!!Object.getOwnPropertySymbols&&!at((function(){var t=Symbol("symbol detection");return!ft(t)||!(Object(t)instanceof Symbol)||!Symbol.sham&&ut&&ut<41})),lt=st&&!Symbol.sham&&"symbol"==typeof Symbol.iterator,pt=$,ht=V,vt=Q,dt=Object,yt=lt?function(t){return"symbol"==typeof t}:function(t){var e=pt("Symbol");return ht(e)&&vt(e.prototype,dt(t))},bt=String,gt=function(t){try{return bt(t)}catch(t){return"Object"}},mt=V,wt=gt,Ot=TypeError,St=function(t){if(mt(t))return t;throw new Ot(wt(t)+" is not a function")},jt=St,Tt=N,Et=function(t,e){var n=t[e];return Tt(n)?void 0:jt(n)},Pt=h,At=V,Ct=K,It=TypeError,xt={exports:{}},Lt=c,Rt=Object.defineProperty,kt=function(t,e){try{Rt(Lt,t,{value:e,configurable:!0,writable:!0})}catch(n){Lt[t]=e}return e},Mt=kt,Nt="__core-js_shared__",_t=c[Nt]||Mt(Nt,{}),Dt=_t;(xt.exports=function(t,e){return Dt[t]||(Dt[t]=void 0!==e?e:{})})("versions",[]).push({version:"3.34.0",mode:"global",copyright:"© 2014-2023 Denis Pushkarev (zloirock.ru)",license:"https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE",source:"https://github.com/zloirock/core-js"});var Ft=xt.exports,Bt=F,Gt=Object,Ut=function(t){return Gt(Bt(t))},zt=Ut,Wt=E({}.hasOwnProperty),Ht=Object.hasOwn||function(t,e){return Wt(zt(t),e)},Vt=E,qt=0,Jt=Math.random(),Kt=Vt(1..toString),Xt=function(t){return"Symbol("+(void 0===t?"":t)+")_"+Kt(++qt+Jt,36)},Yt=Ft,$t=Ht,Qt=Xt,Zt=st,te=lt,ee=c.Symbol,ne=Yt("wks"),re=te?ee.for||ee:ee&&ee.withoutSetter||Qt,oe=function(t){return $t(ne,t)||(ne[t]=Zt&&$t(ee,t)?ee[t]:re("Symbol."+t)),ne[t]},ie=h,ce=K,ue=yt,ae=Et,fe=function(t,e){var n,r;if("string"===e&&At(n=t.toString)&&!Ct(r=Pt(n,t)))return r;if(At(n=t.valueOf)&&!Ct(r=Pt(n,t)))return r;if("string"!==e&&At(n=t.toString)&&!Ct(r=Pt(n,t)))return r;throw new It("Can't convert object to primitive value")},se=TypeError,le=oe("toPrimitive"),pe=function(t,e){if(!ce(t)||ue(t))return t;var n,r=ae(t,le);if(r){if(void 0===e&&(e="default"),n=ie(r,t,e),!ce(n)||ue(n))return n;throw new se("Can't convert object to primitive value")}return void 0===e&&(e="number"),fe(t,e)},he=yt,ve=function(t){var e=pe(t,"string");return he(e)?e:e+""},de=K,ye=c.document,be=de(ye)&&de(ye.createElement),ge=function(t){return be?ye.createElement(t):{}},me=ge,we=!f&&!a((function(){return 7!==Object.defineProperty(me("div"),"a",{get:function(){return 7}}).a})),Oe=f,Se=h,je=v,Te=w,Ee=U,Pe=ve,Ae=Ht,Ce=we,Ie=Object.getOwnPropertyDescriptor;u.f=Oe?Ie:function(t,e){if(t=Ee(t),e=Pe(e),Ce)try{return Ie(t,e)}catch(t){}if(Ae(t,e))return Te(!Se(je.f,t,e),t[e])};var xe={},Le=f&&a((function(){return 42!==Object.defineProperty((function(){}),"prototype",{value:42,writable:!1}).prototype})),Re=K,ke=String,Me=TypeError,Ne=function(t){if(Re(t))return t;throw new Me(ke(t)+" is not an object")},_e=f,De=we,Fe=Le,Be=Ne,Ge=ve,Ue=TypeError,ze=Object.defineProperty,We=Object.getOwnPropertyDescriptor,He="enumerable",Ve="configurable",qe="writable";xe.f=_e?Fe?function(t,e,n){if(Be(t),e=Ge(e),Be(n),"function"==typeof t&&"prototype"===e&&"value"in n&&qe in n&&!n[qe]){var r=We(t,e);r&&r[qe]&&(t[e]=n.value,n={configurable:Ve in n?n[Ve]:r[Ve],enumerable:He in n?n[He]:r[He],writable:!1})}return ze(t,e,n)}:ze:function(t,e,n){if(Be(t),e=Ge(e),Be(n),De)try{return ze(t,e,n)}catch(t){}if("get"in n||"set"in n)throw new Ue("Accessors not supported");return"value"in n&&(t[e]=n.value),t};var Je=xe,Ke=w,Xe=f?function(t,e,n){return Je.f(t,e,Ke(1,n))}:function(t,e,n){return t[e]=n,t},Ye={exports:{}},$e=f,Qe=Ht,Ze=Function.prototype,tn=$e&&Object.getOwnPropertyDescriptor,en=Qe(Ze,"name"),nn={EXISTS:en,PROPER:en&&"something"===function(){}.name,CONFIGURABLE:en&&(!$e||$e&&tn(Ze,"name").configurable)},rn=V,on=_t,cn=E(Function.toString);rn(on.inspectSource)||(on.inspectSource=function(t){return cn(t)});var un,an,fn,sn=on.inspectSource,ln=V,pn=c.WeakMap,hn=ln(pn)&&/native code/.test(String(pn)),vn=Xt,dn=Ft("keys"),yn=function(t){return dn[t]||(dn[t]=vn(t))},bn={},gn=hn,mn=c,wn=K,On=Xe,Sn=Ht,jn=_t,Tn=yn,En=bn,Pn="Object already initialized",An=mn.TypeError,Cn=mn.WeakMap;if(gn||jn.state){var In=jn.state||(jn.state=new Cn);In.get=In.get,In.has=In.has,In.set=In.set,un=function(t,e){if(In.has(t))throw new An(Pn);return e.facade=t,In.set(t,e),e},an=function(t){return In.get(t)||{}},fn=function(t){return In.has(t)}}else{var xn=Tn("state");En[xn]=!0,un=function(t,e){if(Sn(t,xn))throw new An(Pn);return e.facade=t,On(t,xn,e),e},an=function(t){return Sn(t,xn)?t[xn]:{}},fn=function(t){return Sn(t,xn)}}var Ln={set:un,get:an,has:fn,enforce:function(t){return fn(t)?an(t):un(t,{})},getterFor:function(t){return function(e){var n;if(!wn(e)||(n=an(e)).type!==t)throw new An("Incompatible receiver, "+t+" required");return n}}},Rn=E,kn=a,Mn=V,Nn=Ht,_n=f,Dn=nn.CONFIGURABLE,Fn=sn,Bn=Ln.enforce,Gn=Ln.get,Un=String,zn=Object.defineProperty,Wn=Rn("".slice),Hn=Rn("".replace),Vn=Rn([].join),qn=_n&&!kn((function(){return 8!==zn((function(){}),"length",{value:8}).length})),Jn=String(String).split("String"),Kn=Ye.exports=function(t,e,n){"Symbol("===Wn(Un(e),0,7)&&(e="["+Hn(Un(e),/^Symbol\(([^)]*)\)/,"$1")+"]"),n&&n.getter&&(e="get "+e),n&&n.setter&&(e="set "+e),(!Nn(t,"name")||Dn&&t.name!==e)&&(_n?zn(t,"name",{value:e,configurable:!0}):t.name=e),qn&&n&&Nn(n,"arity")&&t.length!==n.arity&&zn(t,"length",{value:n.arity});try{n&&Nn(n,"constructor")&&n.constructor?_n&&zn(t,"prototype",{writable:!1}):t.prototype&&(t.prototype=void 0)}catch(t){}var r=Bn(t);return Nn(r,"source")||(r.source=Vn(Jn,"string"==typeof e?e:"")),t};Function.prototype.toString=Kn((function(){return Mn(this)&&Gn(this).source||Fn(this)}),"toString");var Xn=Ye.exports,Yn=V,$n=xe,Qn=Xn,Zn=kt,tr=function(t,e,n,r){r||(r={});var o=r.enumerable,i=void 0!==r.name?r.name:e;if(Yn(n)&&Qn(n,i,r),r.global)o?t[e]=n:Zn(e,n);else{try{r.unsafe?t[e]&&(o=!0):delete t[e]}catch(t){}o?t[e]=n:$n.f(t,e,{value:n,enumerable:!1,configurable:!r.nonConfigurable,writable:!r.nonWritable})}return t},er={},nr=Math.ceil,rr=Math.floor,or=Math.trunc||function(t){var e=+t;return(e>0?rr:nr)(e)},ir=function(t){var e=+t;return e!=e||0===e?0:or(e)},cr=ir,ur=Math.max,ar=Math.min,fr=function(t,e){var n=cr(t);return n<0?ur(n+e,0):ar(n,e)},sr=ir,lr=Math.min,pr=function(t){return t>0?lr(sr(t),9007199254740991):0},hr=function(t){return pr(t.length)},vr=U,dr=fr,yr=hr,br=function(t){return function(e,n,r){var o,i=vr(e),c=yr(i),u=dr(r,c);if(t&&n!=n){for(;c>u;)if((o=i[u++])!=o)return!0}else for(;c>u;u++)if((t||u in i)&&i[u]===n)return t||u||0;return!t&&-1}},gr={includes:br(!0),indexOf:br(!1)},mr=Ht,wr=U,Or=gr.indexOf,Sr=bn,jr=E([].push),Tr=function(t,e){var n,r=wr(t),o=0,i=[];for(n in r)!mr(Sr,n)&&mr(r,n)&&jr(i,n);for(;e.length>o;)mr(r,n=e[o++])&&(~Or(i,n)||jr(i,n));return i},Er=["constructor","hasOwnProperty","isPrototypeOf","propertyIsEnumerable","toLocaleString","toString","valueOf"],Pr=Tr,Ar=Er.concat("length","prototype");er.f=Object.getOwnPropertyNames||function(t){return Pr(t,Ar)};var Cr={};Cr.f=Object.getOwnPropertySymbols;var Ir=$,xr=er,Lr=Cr,Rr=Ne,kr=E([].concat),Mr=Ir("Reflect","ownKeys")||function(t){var e=xr.f(Rr(t)),n=Lr.f;return n?kr(e,n(t)):e},Nr=Ht,_r=Mr,Dr=u,Fr=xe,Br=a,Gr=V,Ur=/#|\.prototype\./,zr=function(t,e){var n=Hr[Wr(t)];return n===qr||n!==Vr&&(Gr(e)?Br(e):!!e)},Wr=zr.normalize=function(t){return String(t).replace(Ur,".").toLowerCase()},Hr=zr.data={},Vr=zr.NATIVE="N",qr=zr.POLYFILL="P",Jr=zr,Kr=c,Xr=u.f,Yr=Xe,$r=tr,Qr=kt,Zr=function(t,e,n){for(var r=_r(e),o=Fr.f,i=Dr.f,c=0;c9007199254740991)throw oo("Maximum allowed index exceeded");return t},Yo=ao,$o=Bo,Qo=function(t){return Uo>=51||!Go((function(){var e=[];return(e.constructor={})[zo]=function(){return{foo:1}},1!==e[t](Boolean).foo}))},Zo=ct,ti=oe("isConcatSpreadable"),ei=Zo>=51||!Ho((function(){var t=[];return t[ti]=!1,t.concat()[0]!==t})),ni=function(t){if(!qo(t))return!1;var e=t[ti];return void 0!==e?!!e:Vo(t)};Wo({target:"Array",proto:!0,arity:1,forced:!ei||!Qo("concat")},{concat:function(t){var e,n,r,o,i,c=Jo(this),u=$o(c,0),a=0;for(e=-1,r=arguments.length;eo;)for(var u,a=Ei(arguments[o++]),f=i?Ci(Oi(a),i(a)):Oi(a),s=f.length,l=0;s>l;)u=f[l++],bi&&!mi(c,a,u)||(n[u]=a[u]);return n}:Pi,xi=Ii;eo({target:"Object",stat:!0,arity:2,forced:Object.assign!==xi},{assign:xi});var Li=go,Ri=so?{}.toString:function(){return"[object "+Li(this)+"]"};so||tr(Object.prototype,"toString",Ri,{unsafe:!0});var ki,Mi,Ni,_i,Di="process"===I(c.process),Fi=E,Bi=St,Gi=V,Ui=String,zi=TypeError,Wi=function(t,e,n){try{return Fi(Bi(Object.getOwnPropertyDescriptor(t,e)[n]))}catch(t){}},Hi=Ne,Vi=function(t){if("object"==typeof t||Gi(t))return t;throw new zi("Can't set "+Ui(t)+" as a prototype")},qi=Object.setPrototypeOf||("__proto__"in{}?function(){var t,e=!1,n={};try{(t=Wi(Object.prototype,"__proto__","set"))(n,[]),e=n instanceof Array}catch(t){}return function(n,r){return Hi(n),Vi(r),e?t(n,r):n.__proto__=r,n}}():void 0),Ji=xe.f,Ki=Ht,Xi=oe("toStringTag"),Yi=function(t,e,n){t&&!n&&(t=t.prototype),t&&!Ki(t,Xi)&&Ji(t,Xi,{configurable:!0,value:e})},$i=$,Qi=ii,Zi=f,tc=oe("species"),ec=Q,nc=TypeError,rc=function(t,e){if(ec(e,t))return t;throw new nc("Incorrect invocation")},oc=Ro,ic=gt,cc=TypeError,uc=Ne,ac=function(t){if(oc(t))return t;throw new cc(ic(t)+" is not a constructor")},fc=N,sc=oe("species"),lc=s,pc=Function.prototype,hc=pc.apply,vc=pc.call,dc="object"==typeof Reflect&&Reflect.apply||(lc?vc.bind(hc):function(){return vc.apply(hc,arguments)}),yc=I,bc=E,gc=function(t){if("Function"===yc(t))return bc(t)},mc=St,wc=s,Oc=gc(gc.bind),Sc=function(t,e){return mc(t),void 0===e?t:wc?Oc(t,e):function(){return t.apply(e,arguments)}},jc=$("document","documentElement"),Tc=E([].slice),Ec=TypeError,Pc=/(?:ipad|iphone|ipod).*applewebkit/i.test(Z),Ac=c,Cc=dc,Ic=Sc,xc=V,Lc=Ht,Rc=a,kc=jc,Mc=Tc,Nc=ge,_c=function(t,e){if(ti;i++)if((u=b(t[i]))&&bf(jf,u))return u;return new Sf(!1)}r=gf(t,o)}for(a=p?t.next:r.next;!(f=pf(a,r)).done;){try{u=b(f.value)}catch(t){wf(r,"throw",t)}if("object"==typeof u&&u&&bf(jf,u))return u}return new Sf(!1)},Ef=oe("iterator"),Pf=!1;try{var Af=0,Cf={next:function(){return{done:!!Af++}},return:function(){Pf=!0}};Cf[Ef]=function(){return this},Array.from(Cf,(function(){throw 2}))}catch(t){}var If=function(t,e){try{if(!e&&!Pf)return!1}catch(t){return!1}var n=!1;try{var r={};r[Ef]=function(){return{next:function(){return{done:n=!0}}}},t(r)}catch(t){}return n},xf=Cu,Lf=Hu.CONSTRUCTOR||!If((function(t){xf.all(t).then(void 0,(function(){}))})),Rf=h,kf=St,Mf=Vu,Nf=Au,_f=Tf;eo({target:"Promise",stat:!0,forced:Lf},{all:function(t){var e=this,n=Mf.f(e),r=n.resolve,o=n.reject,i=Nf((function(){var n=kf(e.resolve),i=[],c=0,u=1;_f(t,(function(t){var a=c++,f=!1;u++,Rf(n,e,t).then((function(t){f||(f=!0,i[a]=t,--u||r(i))}),o)})),--u||r(i)}));return i.error&&o(i.value),n.promise}});var Df=eo,Ff=Hu.CONSTRUCTOR,Bf=Cu,Gf=$,Uf=V,zf=tr,Wf=Bf&&Bf.prototype;if(Df({target:"Promise",proto:!0,forced:Ff,real:!0},{catch:function(t){return this.then(void 0,t)}}),Uf(Bf)){var Hf=Gf("Promise").prototype.catch;Wf.catch!==Hf&&zf(Wf,"catch",Hf,{unsafe:!0})}var Vf=h,qf=St,Jf=Vu,Kf=Au,Xf=Tf;eo({target:"Promise",stat:!0,forced:Lf},{race:function(t){var e=this,n=Jf.f(e),r=n.reject,o=Kf((function(){var o=qf(e.resolve);Xf(t,(function(t){Vf(o,e,t).then(n.resolve,r)}))}));return o.error&&r(o.value),n.promise}});var Yf=h,$f=Vu;eo({target:"Promise",stat:!0,forced:Hu.CONSTRUCTOR},{reject:function(t){var e=$f.f(this);return Yf(e.reject,void 0,t),e.promise}});var Qf=Ne,Zf=K,ts=Vu,es=eo,ns=Hu.CONSTRUCTOR,rs=function(t,e){if(Qf(t),Zf(e)&&e.constructor===t)return e;var n=ts.f(t);return(0,n.resolve)(e),n.promise};$("Promise"),es({target:"Promise",stat:!0,forced:ns},{resolve:function(t){return rs(this,t)}});var os={},is=f,cs=Le,us=xe,as=Ne,fs=U,ss=yi;os.f=is&&!cs?Object.defineProperties:function(t,e){as(t);for(var n,r=fs(e),o=ss(e),i=o.length,c=0;i>c;)us.f(t,n=o[c++],r[n]);return t};var ls,ps=Ne,hs=os,vs=Er,ds=bn,ys=jc,bs=ge,gs="prototype",ms="script",ws=yn("IE_PROTO"),Os=function(){},Ss=function(t){return"<"+ms+">"+t+""},js=function(t){t.write(Ss("")),t.close();var e=t.parentWindow.Object;return t=null,e},Ts=function(){try{ls=new ActiveXObject("htmlfile")}catch(t){}var t,e,n;Ts="undefined"!=typeof document?document.domain&&ls?js(ls):(e=bs("iframe"),n="java"+ms+":",e.style.display="none",ys.appendChild(e),e.src=String(n),(t=e.contentWindow.document).open(),t.write(Ss("document.F=Object")),t.close(),t.F):js(ls);for(var r=vs.length;r--;)delete Ts[gs][vs[r]];return Ts()};ds[ws]=!0;var Es=Object.create||function(t,e){var n;return null!==t?(Os[gs]=ps(t),n=new Os,Os[gs]=null,n[ws]=t):n=Ts(),void 0===e?n:hs.f(n,e)},Ps=oe,As=Es,Cs=xe.f,Is=Ps("unscopables"),xs=Array.prototype;void 0===xs[Is]&&Cs(xs,Is,{configurable:!0,value:As(null)});var Ls,Rs,ks,Ms=!a((function(){function t(){}return t.prototype.constructor=null,Object.getPrototypeOf(new t)!==t.prototype})),Ns=Ht,_s=V,Ds=Ut,Fs=Ms,Bs=yn("IE_PROTO"),Gs=Object,Us=Gs.prototype,zs=Fs?Gs.getPrototypeOf:function(t){var e=Ds(t);if(Ns(e,Bs))return e[Bs];var n=e.constructor;return _s(n)&&e instanceof n?n.prototype:e instanceof Gs?Us:null},Ws=a,Hs=V,Vs=K,qs=zs,Js=tr,Ks=oe("iterator"),Xs=!1;[].keys&&("next"in(ks=[].keys())?(Rs=qs(qs(ks)))!==Object.prototype&&(Ls=Rs):Xs=!0);var Ys=!Vs(Ls)||Ws((function(){var t={};return Ls[Ks].call(t)!==t}));Ys&&(Ls={}),Hs(Ls[Ks])||Js(Ls,Ks,(function(){return this}));var $s={IteratorPrototype:Ls,BUGGY_SAFARI_ITERATORS:Xs},Qs=$s.IteratorPrototype,Zs=Es,tl=w,el=Yi,nl=Va,rl=function(){return this},ol=eo,il=h,cl=V,ul=function(t,e,n,r){var o=e+" Iterator";return t.prototype=Zs(Qs,{next:tl(+!r,n)}),el(t,o,!1),nl[o]=rl,t},al=zs,fl=qi,sl=Yi,ll=Xe,pl=tr,hl=Va,vl=nn.PROPER,dl=nn.CONFIGURABLE,yl=$s.IteratorPrototype,bl=$s.BUGGY_SAFARI_ITERATORS,gl=oe("iterator"),ml="keys",wl="values",Ol="entries",Sl=function(){return this},jl=function(t,e,n,r,o,i,c){ul(n,e,r);var u,a,f,s=function(t){if(t===o&&d)return d;if(!bl&&t&&t in h)return h[t];switch(t){case ml:case wl:case Ol:return function(){return new n(this,t)}}return function(){return new n(this)}},l=e+" Iterator",p=!1,h=t.prototype,v=h[gl]||h["@@iterator"]||o&&h[o],d=!bl&&v||s(o),y="Array"===e&&h.entries||v;if(y&&(u=al(y.call(new t)))!==Object.prototype&&u.next&&(al(u)!==yl&&(fl?fl(u,yl):cl(u[gl])||pl(u,gl,Sl)),sl(u,l,!0)),vl&&o===wl&&v&&v.name!==wl&&(dl?ll(h,"name",wl):(p=!0,d=function(){return il(v,this)})),o)if(a={values:s(wl),keys:i?d:s(ml),entries:s(Ol)},c)for(f in a)(bl||p||!(f in h))&&pl(h,f,a[f]);else ol({target:e,proto:!0,forced:bl||p},a);return h[gl]!==d&&pl(h,gl,d,{name:o}),hl[e]=d,a},Tl=function(t,e){return{value:t,done:e}},El=U,Pl=function(t){xs[Is][t]=!0},Al=Va,Cl=Ln,Il=xe.f,xl=jl,Ll=Tl,Rl=f,kl="Array Iterator",Ml=Cl.set,Nl=Cl.getterFor(kl),_l=xl(Array,"Array",(function(t,e){Ml(this,{type:kl,target:El(t),index:0,kind:e})}),(function(){var t=Nl(this),e=t.target,n=t.index++;if(!e||n>=e.length)return t.target=void 0,Ll(void 0,!0);switch(t.kind){case"keys":return Ll(n,!1);case"values":return Ll(e[n],!1)}return Ll([n,e[n]],!1)}),"values"),Dl=Al.Arguments=Al.Array;if(Pl("keys"),Pl("values"),Pl("entries"),Rl&&"values"!==Dl.name)try{Il(Dl,"name",{value:"values"})}catch(t){}var Fl=go,Bl=String,Gl=function(t){if("Symbol"===Fl(t))throw new TypeError("Cannot convert a Symbol value to a string");return Bl(t)},Ul=E,zl=ir,Wl=Gl,Hl=F,Vl=Ul("".charAt),ql=Ul("".charCodeAt),Jl=Ul("".slice),Kl=function(t){return function(e,n){var r,o,i=Wl(Hl(e)),c=zl(n),u=i.length;return c<0||c>=u?t?"":void 0:(r=ql(i,c))<55296||r>56319||c+1===u||(o=ql(i,c+1))<56320||o>57343?t?Vl(i,c):r:t?Jl(i,c,c+2):o-56320+(r-55296<<10)+65536}},Xl={codeAt:Kl(!1),charAt:Kl(!0)}.charAt,Yl=Gl,$l=Ln,Ql=jl,Zl=Tl,tp="String Iterator",ep=$l.set,np=$l.getterFor(tp);Ql(String,"String",(function(t){ep(this,{type:tp,string:Yl(t),index:0})}),(function(){var t,e=np(this),n=e.string,r=e.index;return r>=n.length?Zl(void 0,!0):(t=Xl(n,r),e.index+=t.length,Zl(t,!1))}));var rp={exports:{}},op={},ip=fr,cp=hr,up=ao,ap=Array,fp=Math.max,sp=I,lp=U,pp=er.f,hp=function(t,e,n){for(var r=cp(t),o=ip(e,r),i=ip(void 0===n?r:n,r),c=ap(fp(i-o,0)),u=0;og;g++)if((u||g in d)&&(h=b(p=d[g],g,v),t))if(e)w[g]=h;else if(h)switch(t){case 3:return!0;case 5:return p;case 6:return g;case 2:fh(w,p)}else switch(t){case 4:return!1;case 7:fh(w,p)}return i?-1:r||o?o:w}},lh={forEach:sh(0),map:sh(1),filter:sh(2),some:sh(3),every:sh(4),find:sh(5),findIndex:sh(6),filterReject:sh(7)},ph=E,hh=function(t,e,n){for(var r in e)rh(t,r,e[r],n);return t},vh=Fp.getWeakData,dh=rc,yh=Ne,bh=N,gh=K,mh=Tf,wh=Ht,Oh=Ln.set,Sh=Ln.getterFor,jh=lh.find,Th=lh.findIndex,Eh=ph([].splice),Ph=0,Ah=function(t){return t.frozen||(t.frozen=new Ch)},Ch=function(){this.entries=[]},Ih=function(t,e){return jh(t.entries,(function(t){return t[0]===e}))};Ch.prototype={get:function(t){var e=Ih(this,t);if(e)return e[1]},has:function(t){return!!Ih(this,t)},set:function(t,e){var n=Ih(this,t);n?n[1]=e:this.entries.push([t,e])},delete:function(t){var e=Th(this.entries,(function(e){return e[0]===t}));return~e&&Eh(this.entries,e,1),!!~e}};var xh={getConstructor:function(t,e,n,r){var o=t((function(t,o){dh(t,i),Oh(t,{type:e,id:Ph++,frozen:void 0}),bh(o)||mh(o,t[r],{that:t,AS_ENTRIES:n})})),i=o.prototype,c=Sh(e),u=function(t,e,n){var r=c(t),o=vh(yh(e),!0);return!0===o?Ah(r).set(e,n):o[r.id]=n,t};return hh(i,{delete:function(t){var e=c(this);if(!gh(t))return!1;var n=vh(t);return!0===n?Ah(e).delete(t):n&&wh(n,e.id)&&delete n[e.id]},has:function(t){var e=c(this);if(!gh(t))return!1;var n=vh(t);return!0===n?Ah(e).has(t):n&&wh(n,e.id)}}),hh(i,n?{get:function(t){var e=c(this);if(gh(t)){var n=vh(t);return!0===n?Ah(e).get(t):n?n[e.id]:void 0}},set:function(t,e){return u(this,t,e)}}:{add:function(t){return u(this,t,!0)}}),o}};(function(t,e,n){var r=-1!==t.indexOf("Map"),o=-1!==t.indexOf("Weak"),i=r?"set":"add",c=Wp[t],u=c&&c.prototype,a=c,f={},s=function(t){var e=Hp(u[t]);qp(u,t,"add"===t?function(t){return e(this,0===t?0:t),this}:"delete"===t?function(t){return!(o&&!Qp(t))&&e(this,0===t?0:t)}:"get"===t?function(t){return o&&!Qp(t)?void 0:e(this,0===t?0:t)}:"has"===t?function(t){return!(o&&!Qp(t))&&e(this,0===t?0:t)}:function(t,n){return e(this,0===t?0:t,n),this})};if(Vp(t,!Yp(c)||!(o||u.forEach&&!Zp((function(){(new c).entries().next()})))))a=n.getConstructor(e,t,r,i),Jp.enable();else if(Vp(t,!0)){var l=new a,p=l[i](o?{}:-0,1)!==l,h=Zp((function(){l.has(1)})),v=th((function(t){new c(t)})),d=!o&&Zp((function(){for(var t=new c,e=5;e--;)t[i](e,e);return!t.has(-0)}));v||((a=e((function(t,e){Xp(t,u);var n=nh(new c,t,a);return $p(e)||Kp(e,n[i],{that:n,AS_ENTRIES:r}),n}))).prototype=u,u.constructor=a),(h||d)&&(s("delete"),s("has"),r&&s("get")),(d||p)&&s(i),o&&u.clear&&delete u.clear}f[t]=a,zp({global:!0,constructor:!0,forced:a!==c},f),eh(a,t),o||n.setStrong(a,t,r)})("WeakSet",(function(t){return function(){return t(this,arguments.length?arguments[0]:void 0)}}),xh);var Lh,Rh,kh,Mh=ge("span").classList,Nh=Mh&&Mh.constructor&&Mh.constructor.prototype,_h=Nh===Object.prototype?void 0:Nh,Dh=c,Fh={CSSRuleList:0,CSSStyleDeclaration:0,CSSValueList:0,ClientRectList:0,DOMRectList:0,DOMStringList:0,DOMTokenList:1,DataTransferItemList:0,FileList:0,HTMLAllCollection:0,HTMLCollection:0,HTMLFormElement:0,HTMLSelectElement:0,MediaList:0,MimeTypeArray:0,NamedNodeMap:0,NodeList:1,PaintRequestList:0,Plugin:0,PluginArray:0,SVGLengthList:0,SVGNumberList:0,SVGPathSegList:0,SVGPointList:0,SVGStringList:0,SVGTransformList:0,SourceBufferList:0,StyleSheetList:0,TextTrackCueList:0,TextTrackList:0,TouchList:0},Bh=_h,Gh=_l,Uh=Xe,zh=Yi,Wh=oe("iterator"),Hh=Gh.values,Vh=function(t,e){if(t){if(t[Wh]!==Hh)try{Uh(t,Wh,Hh)}catch(e){t[Wh]=Hh}if(zh(t,e,!0),Fh[e])for(var n in Gh)if(t[n]!==Gh[n])try{Uh(t,n,Gh[n])}catch(e){t[n]=Gh[n]}}};for(var qh in Fh)Vh(Dh[qh]&&Dh[qh].prototype,qh);function Jh(t,e,n,r){if("a"===n&&!r)throw new TypeError("Private accessor was defined without a getter");if("function"==typeof e?t!==e||!r:!e.has(t))throw new TypeError("Cannot read private member from an object whose class did not declare it");return"m"===n?r:"a"===n?r.call(t):r?r.value:e.get(t)}Vh(Bh,"DOMTokenList");var Kh="#ch-tooltip",Xh={enabled:!0,text:function(t,e,n){return"".concat(e," - ").concat(n.format("LLLL"))}},Yh={placement:"top",modifiers:[{name:"offset",options:{offset:[0,8]}}]},$h={getBoundingClientRect:function(){var t=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;return{width:0,height:0,top:e,right:t,bottom:e,left:t,x:t,y:e,toJSON:function(){}}}},Qh=function(){function n(t){!function(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}(this,n),Lh.add(this),this.name="Tooltip",this.calendar=t,this.root=null,this.popperInstance=null,this.options=Xh,this.listenerAttached=!1}var r,o,i;return r=n,(o=[{key:"setup",value:function(e){this.options=Object.assign(Object.assign({},Xh),e);var n=this.calendar.eventEmitter;if(!this.options.enabled)return this.listenerAttached&&(n.off("mouseover",this.mouseOverCallback,this),n.off("mouseout",this.mouseOutCallback,this),this.listenerAttached=!1),void this.destroy();if(this.popperOptions=Object.assign(Object.assign({},Yh),this.options),this.root=document.getElementById(Kh.slice(1)),!this.root){var r=document.createElement("div");r.setAttribute("id",Kh.slice(1)),r.setAttribute("role","tooltip"),r.innerHTML='
')+''),this.root=document.body.appendChild(r)}this.root.setAttribute("data-theme",this.calendar.options.options.theme),this.popperInstance=t.createPopper($h,this.root,this.popperOptions),this.listenerAttached||(n.on("mouseover",this.mouseOverCallback,this),n.on("mouseout",this.mouseOutCallback,this),this.listenerAttached=!0)}},{key:"mouseOverCallback",value:function(t,e,n){Jh(this,Lh,"m",Rh).call(this,t.target,e,n)}},{key:"mouseOutCallback",value:function(){Jh(this,Lh,"m",kh).call(this)}},{key:"paint",value:function(){return Promise.resolve()}},{key:"destroy",value:function(){return this.root&&this.root.remove(),Promise.resolve()}}])&&e(r.prototype,o),i&&e(r,i),Object.defineProperty(r,"prototype",{writable:!1}),n}();return Lh=new WeakSet,Rh=function(t,e,r){var o=this,i=this.options.text,c=i?i(e,r,this.calendar.dateHelper.date(e)):null;c&&($h.getBoundingClientRect=function(){return t.getBoundingClientRect()},document.getElementById("".concat(Kh.slice(1),"-body")).innerHTML=c,this.popperInstance.setOptions((function(){return Object.assign(Object.assign({},o.popperOptions),{modifiers:[].concat(n(o.popperOptions.modifiers),[{name:"eventListeners",enabled:!0}])})})),this.popperInstance.update(),this.root.setAttribute("data-show","1"))},kh=function(){var t=this;this.root.removeAttribute("data-show"),this.popperInstance.setOptions((function(){return Object.assign(Object.assign({},t.popperOptions),{modifiers:[].concat(n(t.popperOptions.modifiers),[{name:"eventListeners",enabled:!1}])})}))},Qh}));//# sourceMappingURL=Tooltip.min.js.map diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.js.map b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.js.map new file mode 100644 index 0000000..8f23cfd --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/Tooltip.min.js.map @@ -0,0 +1 @@ +{"version":3,"file":"Tooltip.min.js","sources":["../../node_modules/core-js/internals/global.js","../../node_modules/core-js/internals/fails.js","../../node_modules/core-js/internals/descriptors.js","../../node_modules/core-js/internals/function-bind-native.js","../../node_modules/core-js/internals/function-call.js","../../node_modules/core-js/internals/object-property-is-enumerable.js","../../node_modules/core-js/internals/create-property-descriptor.js","../../node_modules/core-js/internals/engine-v8-version.js","../../node_modules/core-js/internals/function-uncurry-this.js","../../node_modules/core-js/internals/classof-raw.js","../../node_modules/core-js/internals/indexed-object.js","../../node_modules/core-js/internals/is-null-or-undefined.js","../../node_modules/core-js/internals/require-object-coercible.js","../../node_modules/core-js/internals/to-indexed-object.js","../../node_modules/core-js/internals/document-all.js","../../node_modules/core-js/internals/is-callable.js","../../node_modules/core-js/internals/is-object.js","../../node_modules/core-js/internals/get-built-in.js","../../node_modules/core-js/internals/object-is-prototype-of.js","../../node_modules/core-js/internals/engine-user-agent.js","../../node_modules/core-js/internals/symbol-constructor-detection.js","../../node_modules/core-js/internals/use-symbol-as-uid.js","../../node_modules/core-js/internals/is-symbol.js","../../node_modules/core-js/internals/try-to-string.js","../../node_modules/core-js/internals/a-callable.js","../../node_modules/core-js/internals/get-method.js","../../node_modules/core-js/internals/ordinary-to-primitive.js","../../node_modules/core-js/internals/define-global-property.js","../../node_modules/core-js/internals/shared-store.js","../../node_modules/core-js/internals/shared.js","../../node_modules/core-js/internals/to-object.js","../../node_modules/core-js/internals/has-own-property.js","../../node_modules/core-js/internals/uid.js","../../node_modules/core-js/internals/well-known-symbol.js","../../node_modules/core-js/internals/to-primitive.js","../../node_modules/core-js/internals/to-property-key.js","../../node_modules/core-js/internals/document-create-element.js","../../node_modules/core-js/internals/ie8-dom-define.js","../../node_modules/core-js/internals/object-get-own-property-descriptor.js","../../node_modules/core-js/internals/v8-prototype-define-bug.js","../../node_modules/core-js/internals/an-object.js","../../node_modules/core-js/internals/object-define-property.js","../../node_modules/core-js/internals/create-non-enumerable-property.js","../../node_modules/core-js/internals/function-name.js","../../node_modules/core-js/internals/inspect-source.js","../../node_modules/core-js/internals/internal-state.js","../../node_modules/core-js/internals/weak-map-basic-detection.js","../../node_modules/core-js/internals/shared-key.js","../../node_modules/core-js/internals/hidden-keys.js","../../node_modules/core-js/internals/make-built-in.js","../../node_modules/core-js/internals/define-built-in.js","../../node_modules/core-js/internals/math-trunc.js","../../node_modules/core-js/internals/to-integer-or-infinity.js","../../node_modules/core-js/internals/to-absolute-index.js","../../node_modules/core-js/internals/to-length.js","../../node_modules/core-js/internals/length-of-array-like.js","../../node_modules/core-js/internals/array-includes.js","../../node_modules/core-js/internals/object-keys-internal.js","../../node_modules/core-js/internals/enum-bug-keys.js","../../node_modules/core-js/internals/object-get-own-property-names.js","../../node_modules/core-js/internals/object-get-own-property-symbols.js","../../node_modules/core-js/internals/own-keys.js","../../node_modules/core-js/internals/copy-constructor-properties.js","../../node_modules/core-js/internals/is-forced.js","../../node_modules/core-js/internals/export.js","../../node_modules/core-js/internals/is-array.js","../../node_modules/core-js/internals/does-not-exceed-safe-integer.js","../../node_modules/core-js/internals/create-property.js","../../node_modules/core-js/internals/to-string-tag-support.js","../../node_modules/core-js/internals/classof.js","../../node_modules/core-js/internals/is-constructor.js","../../node_modules/core-js/internals/array-species-constructor.js","../../node_modules/core-js/internals/array-species-create.js","../../node_modules/core-js/internals/array-method-has-species-support.js","../../node_modules/core-js/modules/es.array.concat.js","../../node_modules/core-js/internals/define-built-in-accessor.js","../../node_modules/core-js/modules/es.function.name.js","../../node_modules/core-js/internals/object-keys.js","../../node_modules/core-js/internals/object-assign.js","../../node_modules/core-js/modules/es.object.assign.js","../../node_modules/core-js/internals/object-to-string.js","../../node_modules/core-js/modules/es.object.to-string.js","../../node_modules/core-js/internals/engine-is-node.js","../../node_modules/core-js/internals/task.js","../../node_modules/core-js/internals/function-uncurry-this-accessor.js","../../node_modules/core-js/internals/a-possible-prototype.js","../../node_modules/core-js/internals/object-set-prototype-of.js","../../node_modules/core-js/internals/set-to-string-tag.js","../../node_modules/core-js/internals/set-species.js","../../node_modules/core-js/internals/an-instance.js","../../node_modules/core-js/internals/a-constructor.js","../../node_modules/core-js/internals/species-constructor.js","../../node_modules/core-js/internals/function-apply.js","../../node_modules/core-js/internals/function-uncurry-this-clause.js","../../node_modules/core-js/internals/function-bind-context.js","../../node_modules/core-js/internals/html.js","../../node_modules/core-js/internals/array-slice.js","../../node_modules/core-js/internals/validate-arguments-length.js","../../node_modules/core-js/internals/engine-is-ios.js","../../node_modules/core-js/internals/queue.js","../../node_modules/core-js/internals/microtask.js","../../node_modules/core-js/internals/engine-is-ios-pebble.js","../../node_modules/core-js/internals/engine-is-webos-webkit.js","../../node_modules/core-js/internals/perform.js","../../node_modules/core-js/internals/promise-native-constructor.js","../../node_modules/core-js/internals/engine-is-deno.js","../../node_modules/core-js/internals/engine-is-browser.js","../../node_modules/core-js/internals/promise-constructor-detection.js","../../node_modules/core-js/internals/new-promise-capability.js","../../node_modules/core-js/modules/es.promise.constructor.js","../../node_modules/core-js/internals/host-report-errors.js","../../node_modules/core-js/internals/iterators.js","../../node_modules/core-js/internals/is-array-iterator-method.js","../../node_modules/core-js/internals/get-iterator-method.js","../../node_modules/core-js/internals/get-iterator.js","../../node_modules/core-js/internals/iterator-close.js","../../node_modules/core-js/internals/iterate.js","../../node_modules/core-js/internals/check-correctness-of-iteration.js","../../node_modules/core-js/internals/promise-statics-incorrect-iteration.js","../../node_modules/core-js/modules/es.promise.all.js","../../node_modules/core-js/modules/es.promise.catch.js","../../node_modules/core-js/modules/es.promise.race.js","../../node_modules/core-js/modules/es.promise.reject.js","../../node_modules/core-js/internals/promise-resolve.js","../../node_modules/core-js/modules/es.promise.resolve.js","../../node_modules/core-js/internals/object-define-properties.js","../../node_modules/core-js/internals/object-create.js","../../node_modules/core-js/internals/add-to-unscopables.js","../../node_modules/core-js/internals/iterators-core.js","../../node_modules/core-js/internals/correct-prototype-getter.js","../../node_modules/core-js/internals/object-get-prototype-of.js","../../node_modules/core-js/internals/iterator-create-constructor.js","../../node_modules/core-js/internals/iterator-define.js","../../node_modules/core-js/internals/create-iter-result-object.js","../../node_modules/core-js/modules/es.array.iterator.js","../../node_modules/core-js/internals/to-string.js","../../node_modules/core-js/internals/string-multibyte.js","../../node_modules/core-js/modules/es.string.iterator.js","../../node_modules/core-js/internals/array-slice-simple.js","../../node_modules/core-js/internals/object-get-own-property-names-external.js","../../node_modules/core-js/internals/array-buffer-non-extensible.js","../../node_modules/core-js/internals/object-is-extensible.js","../../node_modules/core-js/internals/freezing.js","../../node_modules/core-js/internals/internal-metadata.js","../../node_modules/core-js/internals/inherit-if-required.js","../../node_modules/core-js/internals/collection.js","../../node_modules/core-js/internals/define-built-ins.js","../../node_modules/core-js/internals/array-iteration.js","../../node_modules/core-js/internals/collection-weak.js","../../node_modules/core-js/modules/es.weak-set.constructor.js","../../node_modules/core-js/internals/dom-iterables.js","../../node_modules/core-js/internals/dom-token-list-prototype.js","../../node_modules/core-js/modules/web.dom-collections.iterator.js","../../node_modules/tslib/tslib.es6.js","../../../src/plugins/Tooltip.ts"],"sourcesContent":["'use strict';\nvar check = function (it) {\n return it && it.Math === Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n // eslint-disable-next-line es/no-global-this -- safe\n check(typeof globalThis == 'object' && globalThis) ||\n check(typeof window == 'object' && window) ||\n // eslint-disable-next-line no-restricted-globals -- safe\n check(typeof self == 'object' && self) ||\n check(typeof global == 'object' && global) ||\n check(typeof this == 'object' && this) ||\n // eslint-disable-next-line no-new-func -- fallback\n (function () { return this; })() || Function('return this')();\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return !!exec();\n } catch (error) {\n return true;\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\n// Detect IE8's incomplete defineProperty implementation\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;\n});\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-function-prototype-bind -- safe\n var test = (function () { /* empty */ }).bind();\n // eslint-disable-next-line no-prototype-builtins -- safe\n return typeof test != 'function' || test.hasOwnProperty('prototype');\n});\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar call = Function.prototype.call;\n\nmodule.exports = NATIVE_BIND ? call.bind(call) : function () {\n return call.apply(call, arguments);\n};\n","'use strict';\nvar $propertyIsEnumerable = {}.propertyIsEnumerable;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n var descriptor = getOwnPropertyDescriptor(this, V);\n return !!descriptor && descriptor.enumerable;\n} : $propertyIsEnumerable;\n","'use strict';\nmodule.exports = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n","'use strict';\nvar global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar Deno = global.Deno;\nvar versions = process && process.versions || Deno && Deno.version;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n match = v8.split('.');\n // in old Chrome, versions of V8 isn't V8 = Chrome / 10\n // but their correct versions are not interesting for us\n version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);\n}\n\n// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`\n// so check `userAgent` even if `.v8` exists, but 0\nif (!version && userAgent) {\n match = userAgent.match(/Edge\\/(\\d+)/);\n if (!match || match[1] >= 74) {\n match = userAgent.match(/Chrome\\/(\\d+)/);\n if (match) version = +match[1];\n }\n}\n\nmodule.exports = version;\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar call = FunctionPrototype.call;\nvar uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);\n\nmodule.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {\n return function () {\n return call.apply(fn, arguments);\n };\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar toString = uncurryThis({}.toString);\nvar stringSlice = uncurryThis(''.slice);\n\nmodule.exports = function (it) {\n return stringSlice(toString(it), 8, -1);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar $Object = Object;\nvar split = uncurryThis(''.split);\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n // eslint-disable-next-line no-prototype-builtins -- safe\n return !$Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n return classof(it) === 'String' ? split(it, '') : $Object(it);\n} : $Object;\n","'use strict';\n// we can't use just `it == null` since of `document.all` special case\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec\nmodule.exports = function (it) {\n return it === null || it === undefined;\n};\n","'use strict';\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\nvar $TypeError = TypeError;\n\n// `RequireObjectCoercible` abstract operation\n// https://tc39.es/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n if (isNullOrUndefined(it)) throw new $TypeError(\"Can't call method on \" + it);\n return it;\n};\n","'use strict';\n// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n return IndexedObject(requireObjectCoercible(it));\n};\n","'use strict';\nvar documentAll = typeof document == 'object' && document.all;\n\n// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot\n// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing\nvar IS_HTMLDDA = typeof documentAll == 'undefined' && documentAll !== undefined;\n\nmodule.exports = {\n all: documentAll,\n IS_HTMLDDA: IS_HTMLDDA\n};\n","'use strict';\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\n// `IsCallable` abstract operation\n// https://tc39.es/ecma262/#sec-iscallable\nmodule.exports = $documentAll.IS_HTMLDDA ? function (argument) {\n return typeof argument == 'function' || argument === documentAll;\n} : function (argument) {\n return typeof argument == 'function';\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar $documentAll = require('../internals/document-all');\n\nvar documentAll = $documentAll.all;\n\nmodule.exports = $documentAll.IS_HTMLDDA ? function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it) || it === documentAll;\n} : function (it) {\n return typeof it == 'object' ? it !== null : isCallable(it);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar aFunction = function (argument) {\n return isCallable(argument) ? argument : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n return arguments.length < 2 ? aFunction(global[namespace]) : global[namespace] && global[namespace][method];\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis({}.isPrototypeOf);\n","'use strict';\nmodule.exports = typeof navigator != 'undefined' && String(navigator.userAgent) || '';\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar V8_VERSION = require('../internals/engine-v8-version');\nvar fails = require('../internals/fails');\nvar global = require('../internals/global');\n\nvar $String = global.String;\n\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n var symbol = Symbol('symbol detection');\n // Chrome 38 Symbol has incorrect toString conversion\n // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances\n // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,\n // of course, fail.\n return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||\n // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances\n !Symbol.sham && V8_VERSION && V8_VERSION < 41;\n});\n","'use strict';\n/* eslint-disable es/no-symbol -- required for testing */\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\n\nmodule.exports = NATIVE_SYMBOL\n && !Symbol.sham\n && typeof Symbol.iterator == 'symbol';\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar $Object = Object;\n\nmodule.exports = USE_SYMBOL_AS_UID ? function (it) {\n return typeof it == 'symbol';\n} : function (it) {\n var $Symbol = getBuiltIn('Symbol');\n return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));\n};\n","'use strict';\nvar $String = String;\n\nmodule.exports = function (argument) {\n try {\n return $String(argument);\n } catch (error) {\n return 'Object';\n }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsCallable(argument) is true`\nmodule.exports = function (argument) {\n if (isCallable(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a function');\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\n\n// `GetMethod` abstract operation\n// https://tc39.es/ecma262/#sec-getmethod\nmodule.exports = function (V, P) {\n var func = V[P];\n return isNullOrUndefined(func) ? undefined : aCallable(func);\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\n\nvar $TypeError = TypeError;\n\n// `OrdinaryToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-ordinarytoprimitive\nmodule.exports = function (input, pref) {\n var fn, val;\n if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;\n if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;\n throw new $TypeError(\"Can't convert object to primitive value\");\n};\n","'use strict';\nvar global = require('../internals/global');\n\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\n\nmodule.exports = function (key, value) {\n try {\n defineProperty(global, key, { value: value, configurable: true, writable: true });\n } catch (error) {\n global[key] = value;\n } return value;\n};\n","'use strict';\nvar global = require('../internals/global');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || defineGlobalProperty(SHARED, {});\n\nmodule.exports = store;\n","'use strict';\nvar IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n version: '3.34.0',\n mode: IS_PURE ? 'pure' : 'global',\n copyright: '© 2014-2023 Denis Pushkarev (zloirock.ru)',\n license: 'https://github.com/zloirock/core-js/blob/v3.34.0/LICENSE',\n source: 'https://github.com/zloirock/core-js'\n});\n","'use strict';\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar $Object = Object;\n\n// `ToObject` abstract operation\n// https://tc39.es/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n return $Object(requireObjectCoercible(argument));\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toObject = require('../internals/to-object');\n\nvar hasOwnProperty = uncurryThis({}.hasOwnProperty);\n\n// `HasOwnProperty` abstract operation\n// https://tc39.es/ecma262/#sec-hasownproperty\n// eslint-disable-next-line es/no-object-hasown -- safe\nmodule.exports = Object.hasOwn || function hasOwn(it, key) {\n return hasOwnProperty(toObject(it), key);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nvar id = 0;\nvar postfix = Math.random();\nvar toString = uncurryThis(1.0.toString);\n\nmodule.exports = function (key) {\n return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);\n};\n","'use strict';\nvar global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar hasOwn = require('../internals/has-own-property');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/symbol-constructor-detection');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar Symbol = global.Symbol;\nvar WellKnownSymbolsStore = shared('wks');\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n if (!hasOwn(WellKnownSymbolsStore, name)) {\n WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)\n ? Symbol[name]\n : createWellKnownSymbol('Symbol.' + name);\n } return WellKnownSymbolsStore[name];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar isObject = require('../internals/is-object');\nvar isSymbol = require('../internals/is-symbol');\nvar getMethod = require('../internals/get-method');\nvar ordinaryToPrimitive = require('../internals/ordinary-to-primitive');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $TypeError = TypeError;\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\n\n// `ToPrimitive` abstract operation\n// https://tc39.es/ecma262/#sec-toprimitive\nmodule.exports = function (input, pref) {\n if (!isObject(input) || isSymbol(input)) return input;\n var exoticToPrim = getMethod(input, TO_PRIMITIVE);\n var result;\n if (exoticToPrim) {\n if (pref === undefined) pref = 'default';\n result = call(exoticToPrim, input, pref);\n if (!isObject(result) || isSymbol(result)) return result;\n throw new $TypeError(\"Can't convert object to primitive value\");\n }\n if (pref === undefined) pref = 'number';\n return ordinaryToPrimitive(input, pref);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar isSymbol = require('../internals/is-symbol');\n\n// `ToPropertyKey` abstract operation\n// https://tc39.es/ecma262/#sec-topropertykey\nmodule.exports = function (argument) {\n var key = toPrimitive(argument, 'string');\n return isSymbol(key) ? key : key + '';\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n return EXISTS ? document.createElement(it) : {};\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thanks to IE8 for its funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(createElement('div'), 'a', {\n get: function () { return 7; }\n }).a !== 7;\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar call = require('../internals/function-call');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPropertyKey = require('../internals/to-property-key');\nvar hasOwn = require('../internals/has-own-property');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n O = toIndexedObject(O);\n P = toPropertyKey(P);\n if (IE8_DOM_DEFINE) try {\n return $getOwnPropertyDescriptor(O, P);\n } catch (error) { /* empty */ }\n if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\n\n// V8 ~ Chrome 36-\n// https://bugs.chromium.org/p/v8/issues/detail?id=3334\nmodule.exports = DESCRIPTORS && fails(function () {\n // eslint-disable-next-line es/no-object-defineproperty -- required for testing\n return Object.defineProperty(function () { /* empty */ }, 'prototype', {\n value: 42,\n writable: false\n }).prototype !== 42;\n});\n","'use strict';\nvar isObject = require('../internals/is-object');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\n// `Assert: Type(argument) is Object`\nmodule.exports = function (argument) {\n if (isObject(argument)) return argument;\n throw new $TypeError($String(argument) + ' is not an object');\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar anObject = require('../internals/an-object');\nvar toPropertyKey = require('../internals/to-property-key');\n\nvar $TypeError = TypeError;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar $defineProperty = Object.defineProperty;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar ENUMERABLE = 'enumerable';\nvar CONFIGURABLE = 'configurable';\nvar WRITABLE = 'writable';\n\n// `Object.defineProperty` method\n// https://tc39.es/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {\n var current = $getOwnPropertyDescriptor(O, P);\n if (current && current[WRITABLE]) {\n O[P] = Attributes.value;\n Attributes = {\n configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],\n enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],\n writable: false\n };\n }\n } return $defineProperty(O, P, Attributes);\n} : $defineProperty : function defineProperty(O, P, Attributes) {\n anObject(O);\n P = toPropertyKey(P);\n anObject(Attributes);\n if (IE8_DOM_DEFINE) try {\n return $defineProperty(O, P, Attributes);\n } catch (error) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar hasOwn = require('../internals/has-own-property');\n\nvar FunctionPrototype = Function.prototype;\n// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\nvar getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;\n\nvar EXISTS = hasOwn(FunctionPrototype, 'name');\n// additional protection from minified / mangled / dropped function names\nvar PROPER = EXISTS && (function something() { /* empty */ }).name === 'something';\nvar CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));\n\nmodule.exports = {\n EXISTS: EXISTS,\n PROPER: PROPER,\n CONFIGURABLE: CONFIGURABLE\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isCallable = require('../internals/is-callable');\nvar store = require('../internals/shared-store');\n\nvar functionToString = uncurryThis(Function.toString);\n\n// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper\nif (!isCallable(store.inspectSource)) {\n store.inspectSource = function (it) {\n return functionToString(it);\n };\n}\n\nmodule.exports = store.inspectSource;\n","'use strict';\nvar NATIVE_WEAK_MAP = require('../internals/weak-map-basic-detection');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar hasOwn = require('../internals/has-own-property');\nvar shared = require('../internals/shared-store');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar OBJECT_ALREADY_INITIALIZED = 'Object already initialized';\nvar TypeError = global.TypeError;\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n return function (it) {\n var state;\n if (!isObject(it) || (state = get(it)).type !== TYPE) {\n throw new TypeError('Incompatible receiver, ' + TYPE + ' required');\n } return state;\n };\n};\n\nif (NATIVE_WEAK_MAP || shared.state) {\n var store = shared.state || (shared.state = new WeakMap());\n /* eslint-disable no-self-assign -- prototype methods protection */\n store.get = store.get;\n store.has = store.has;\n store.set = store.set;\n /* eslint-enable no-self-assign -- prototype methods protection */\n set = function (it, metadata) {\n if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n store.set(it, metadata);\n return metadata;\n };\n get = function (it) {\n return store.get(it) || {};\n };\n has = function (it) {\n return store.has(it);\n };\n} else {\n var STATE = sharedKey('state');\n hiddenKeys[STATE] = true;\n set = function (it, metadata) {\n if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);\n metadata.facade = it;\n createNonEnumerableProperty(it, STATE, metadata);\n return metadata;\n };\n get = function (it) {\n return hasOwn(it, STATE) ? it[STATE] : {};\n };\n has = function (it) {\n return hasOwn(it, STATE);\n };\n}\n\nmodule.exports = {\n set: set,\n get: get,\n has: has,\n enforce: enforce,\n getterFor: getterFor\n};\n","'use strict';\nvar global = require('../internals/global');\nvar isCallable = require('../internals/is-callable');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));\n","'use strict';\nvar shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n return keys[key] || (keys[key] = uid(key));\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar CONFIGURABLE_FUNCTION_NAME = require('../internals/function-name').CONFIGURABLE;\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar enforceInternalState = InternalStateModule.enforce;\nvar getInternalState = InternalStateModule.get;\nvar $String = String;\n// eslint-disable-next-line es/no-object-defineproperty -- safe\nvar defineProperty = Object.defineProperty;\nvar stringSlice = uncurryThis(''.slice);\nvar replace = uncurryThis(''.replace);\nvar join = uncurryThis([].join);\n\nvar CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {\n return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;\n});\n\nvar TEMPLATE = String(String).split('String');\n\nvar makeBuiltIn = module.exports = function (value, name, options) {\n if (stringSlice($String(name), 0, 7) === 'Symbol(') {\n name = '[' + replace($String(name), /^Symbol\\(([^)]*)\\)/, '$1') + ']';\n }\n if (options && options.getter) name = 'get ' + name;\n if (options && options.setter) name = 'set ' + name;\n if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {\n if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });\n else value.name = name;\n }\n if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {\n defineProperty(value, 'length', { value: options.arity });\n }\n try {\n if (options && hasOwn(options, 'constructor') && options.constructor) {\n if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });\n // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable\n } else if (value.prototype) value.prototype = undefined;\n } catch (error) { /* empty */ }\n var state = enforceInternalState(value);\n if (!hasOwn(state, 'source')) {\n state.source = join(TEMPLATE, typeof name == 'string' ? name : '');\n } return value;\n};\n\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n// eslint-disable-next-line no-extend-native -- required\nFunction.prototype.toString = makeBuiltIn(function toString() {\n return isCallable(this) && getInternalState(this).source || inspectSource(this);\n}, 'toString');\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar definePropertyModule = require('../internals/object-define-property');\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\n\nmodule.exports = function (O, key, value, options) {\n if (!options) options = {};\n var simple = options.enumerable;\n var name = options.name !== undefined ? options.name : key;\n if (isCallable(value)) makeBuiltIn(value, name, options);\n if (options.global) {\n if (simple) O[key] = value;\n else defineGlobalProperty(key, value);\n } else {\n try {\n if (!options.unsafe) delete O[key];\n else if (O[key]) simple = true;\n } catch (error) { /* empty */ }\n if (simple) O[key] = value;\n else definePropertyModule.f(O, key, {\n value: value,\n enumerable: false,\n configurable: !options.nonConfigurable,\n writable: !options.nonWritable\n });\n } return O;\n};\n","'use strict';\nvar ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `Math.trunc` method\n// https://tc39.es/ecma262/#sec-math.trunc\n// eslint-disable-next-line es/no-math-trunc -- safe\nmodule.exports = Math.trunc || function trunc(x) {\n var n = +x;\n return (n > 0 ? floor : ceil)(n);\n};\n","'use strict';\nvar trunc = require('../internals/math-trunc');\n\n// `ToIntegerOrInfinity` abstract operation\n// https://tc39.es/ecma262/#sec-tointegerorinfinity\nmodule.exports = function (argument) {\n var number = +argument;\n // eslint-disable-next-line no-self-compare -- NaN check\n return number !== number || number === 0 ? 0 : trunc(number);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n var integer = toIntegerOrInfinity(index);\n return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","'use strict';\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.es/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n return argument > 0 ? min(toIntegerOrInfinity(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","'use strict';\nvar toLength = require('../internals/to-length');\n\n// `LengthOfArrayLike` abstract operation\n// https://tc39.es/ecma262/#sec-lengthofarraylike\nmodule.exports = function (obj) {\n return toLength(obj.length);\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n return function ($this, el, fromIndex) {\n var O = toIndexedObject($this);\n var length = lengthOfArrayLike(O);\n var index = toAbsoluteIndex(fromIndex, length);\n var value;\n // Array#includes uses SameValueZero equality algorithm\n // eslint-disable-next-line no-self-compare -- NaN check\n if (IS_INCLUDES && el !== el) while (length > index) {\n value = O[index++];\n // eslint-disable-next-line no-self-compare -- NaN check\n if (value !== value) return true;\n // Array#indexOf ignores holes, Array#includes - not\n } else for (;length > index; index++) {\n if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n } return !IS_INCLUDES && -1;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.includes` method\n // https://tc39.es/ecma262/#sec-array.prototype.includes\n includes: createMethod(true),\n // `Array.prototype.indexOf` method\n // https://tc39.es/ecma262/#sec-array.prototype.indexof\n indexOf: createMethod(false)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hasOwn = require('../internals/has-own-property');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar push = uncurryThis([].push);\n\nmodule.exports = function (object, names) {\n var O = toIndexedObject(object);\n var i = 0;\n var result = [];\n var key;\n for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);\n // Don't enum bug & hidden keys\n while (names.length > i) if (hasOwn(O, key = names[i++])) {\n ~indexOf(result, key) || push(result, key);\n }\n return result;\n};\n","'use strict';\n// IE8- don't enum bug keys\nmodule.exports = [\n 'constructor',\n 'hasOwnProperty',\n 'isPrototypeOf',\n 'propertyIsEnumerable',\n 'toLocaleString',\n 'toString',\n 'valueOf'\n];\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.es/ecma262/#sec-object.getownpropertynames\n// eslint-disable-next-line es/no-object-getownpropertynames -- safe\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n return internalObjectKeys(O, hiddenKeys);\n};\n","'use strict';\n// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe\nexports.f = Object.getOwnPropertySymbols;\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\nvar concat = uncurryThis([].concat);\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n var keys = getOwnPropertyNamesModule.f(anObject(it));\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;\n};\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source, exceptions) {\n var keys = ownKeys(source);\n var defineProperty = definePropertyModule.f;\n var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n for (var i = 0; i < keys.length; i++) {\n var key = keys[i];\n if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {\n defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n }\n }\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n var value = data[normalize(feature)];\n return value === POLYFILL ? true\n : value === NATIVE ? false\n : isCallable(detection) ? fails(detection)\n : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","'use strict';\nvar global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar defineGlobalProperty = require('../internals/define-global-property');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n options.target - name of the target object\n options.global - target is the global object\n options.stat - export as static methods of target\n options.proto - export as prototype methods of target\n options.real - real prototype method for the `pure` version\n options.forced - export even if the native feature is available\n options.bind - bind methods to the target, required for the `pure` version\n options.wrap - wrap constructors to preventing global pollution, required for the `pure` version\n options.unsafe - use the simple assignment of property instead of delete + defineProperty\n options.sham - add a flag to not completely full polyfills\n options.enumerable - export as enumerable property\n options.dontCallGetSet - prevent calling a getter on target\n options.name - the .name of the function if it does not match the key\n*/\nmodule.exports = function (options, source) {\n var TARGET = options.target;\n var GLOBAL = options.global;\n var STATIC = options.stat;\n var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n if (GLOBAL) {\n target = global;\n } else if (STATIC) {\n target = global[TARGET] || defineGlobalProperty(TARGET, {});\n } else {\n target = (global[TARGET] || {}).prototype;\n }\n if (target) for (key in source) {\n sourceProperty = source[key];\n if (options.dontCallGetSet) {\n descriptor = getOwnPropertyDescriptor(target, key);\n targetProperty = descriptor && descriptor.value;\n } else targetProperty = target[key];\n FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n // contained in target\n if (!FORCED && targetProperty !== undefined) {\n if (typeof sourceProperty == typeof targetProperty) continue;\n copyConstructorProperties(sourceProperty, targetProperty);\n }\n // add a flag to not completely full polyfills\n if (options.sham || (targetProperty && targetProperty.sham)) {\n createNonEnumerableProperty(sourceProperty, 'sham', true);\n }\n defineBuiltIn(target, key, sourceProperty, options);\n }\n};\n","'use strict';\nvar classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.es/ecma262/#sec-isarray\n// eslint-disable-next-line es/no-array-isarray -- safe\nmodule.exports = Array.isArray || function isArray(argument) {\n return classof(argument) === 'Array';\n};\n","'use strict';\nvar $TypeError = TypeError;\nvar MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991\n\nmodule.exports = function (it) {\n if (it > MAX_SAFE_INTEGER) throw $TypeError('Maximum allowed index exceeded');\n return it;\n};\n","'use strict';\nvar toPropertyKey = require('../internals/to-property-key');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n var propertyKey = toPropertyKey(key);\n if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n else object[propertyKey] = value;\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar isCallable = require('../internals/is-callable');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar $Object = Object;\n\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n try {\n return it[key];\n } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n var O, tag, result;\n return it === undefined ? 'Undefined' : it === null ? 'Null'\n // @@toStringTag case\n : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag\n // builtinTag case\n : CORRECT_ARGUMENTS ? classofRaw(O)\n // ES3 arguments fallback\n : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar classof = require('../internals/classof');\nvar getBuiltIn = require('../internals/get-built-in');\nvar inspectSource = require('../internals/inspect-source');\n\nvar noop = function () { /* empty */ };\nvar empty = [];\nvar construct = getBuiltIn('Reflect', 'construct');\nvar constructorRegExp = /^\\s*(?:class|function)\\b/;\nvar exec = uncurryThis(constructorRegExp.exec);\nvar INCORRECT_TO_STRING = !constructorRegExp.test(noop);\n\nvar isConstructorModern = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n try {\n construct(noop, empty, argument);\n return true;\n } catch (error) {\n return false;\n }\n};\n\nvar isConstructorLegacy = function isConstructor(argument) {\n if (!isCallable(argument)) return false;\n switch (classof(argument)) {\n case 'AsyncFunction':\n case 'GeneratorFunction':\n case 'AsyncGeneratorFunction': return false;\n }\n try {\n // we can't check .prototype since constructors produced by .bind haven't it\n // `Function#toString` throws on some built-it function in some legacy engines\n // (for example, `DOMQuad` and similar in FF41-)\n return INCORRECT_TO_STRING || !!exec(constructorRegExp, inspectSource(argument));\n } catch (error) {\n return true;\n }\n};\n\nisConstructorLegacy.sham = true;\n\n// `IsConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-isconstructor\nmodule.exports = !construct || fails(function () {\n var called;\n return isConstructorModern(isConstructorModern.call)\n || !isConstructorModern(Object)\n || !isConstructorModern(function () { called = true; })\n || called;\n}) ? isConstructorLegacy : isConstructorModern;\n","'use strict';\nvar isArray = require('../internals/is-array');\nvar isConstructor = require('../internals/is-constructor');\nvar isObject = require('../internals/is-object');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\nvar $Array = Array;\n\n// a part of `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray) {\n var C;\n if (isArray(originalArray)) {\n C = originalArray.constructor;\n // cross-realm fallback\n if (isConstructor(C) && (C === $Array || isArray(C.prototype))) C = undefined;\n else if (isObject(C)) {\n C = C[SPECIES];\n if (C === null) C = undefined;\n }\n } return C === undefined ? $Array : C;\n};\n","'use strict';\nvar arraySpeciesConstructor = require('../internals/array-species-constructor');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.es/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n return new (arraySpeciesConstructor(originalArray))(length === 0 ? 0 : length);\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (METHOD_NAME) {\n // We can't use this feature detection in V8 since it causes\n // deoptimization and serious performance degradation\n // https://github.com/zloirock/core-js/issues/677\n return V8_VERSION >= 51 || !fails(function () {\n var array = [];\n var constructor = array.constructor = {};\n constructor[SPECIES] = function () {\n return { foo: 1 };\n };\n return array[METHOD_NAME](Boolean).foo !== 1;\n });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar isArray = require('../internals/is-array');\nvar isObject = require('../internals/is-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar doesNotExceedSafeInteger = require('../internals/does-not-exceed-safe-integer');\nvar createProperty = require('../internals/create-property');\nvar arraySpeciesCreate = require('../internals/array-species-create');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');\n\n// We can't use this feature detection in V8 since it causes\n// deoptimization and serious performance degradation\n// https://github.com/zloirock/core-js/issues/679\nvar IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {\n var array = [];\n array[IS_CONCAT_SPREADABLE] = false;\n return array.concat()[0] !== array;\n});\n\nvar isConcatSpreadable = function (O) {\n if (!isObject(O)) return false;\n var spreadable = O[IS_CONCAT_SPREADABLE];\n return spreadable !== undefined ? !!spreadable : isArray(O);\n};\n\nvar FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !arrayMethodHasSpeciesSupport('concat');\n\n// `Array.prototype.concat` method\n// https://tc39.es/ecma262/#sec-array.prototype.concat\n// with adding support of @@isConcatSpreadable and @@species\n$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n concat: function concat(arg) {\n var O = toObject(this);\n var A = arraySpeciesCreate(O, 0);\n var n = 0;\n var i, k, length, len, E;\n for (i = -1, length = arguments.length; i < length; i++) {\n E = i === -1 ? O : arguments[i];\n if (isConcatSpreadable(E)) {\n len = lengthOfArrayLike(E);\n doesNotExceedSafeInteger(n + len);\n for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);\n } else {\n doesNotExceedSafeInteger(n + 1);\n createProperty(A, n++, E);\n }\n }\n A.length = n;\n return A;\n }\n});\n","'use strict';\nvar makeBuiltIn = require('../internals/make-built-in');\nvar defineProperty = require('../internals/object-define-property');\n\nmodule.exports = function (target, name, descriptor) {\n if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });\n if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });\n return defineProperty.f(target, name, descriptor);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar FUNCTION_NAME_EXISTS = require('../internals/function-name').EXISTS;\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\n\nvar FunctionPrototype = Function.prototype;\nvar functionToString = uncurryThis(FunctionPrototype.toString);\nvar nameRE = /function\\b(?:\\s|\\/\\*[\\S\\s]*?\\*\\/|\\/\\/[^\\n\\r]*[\\n\\r]+)*([^\\s(/]*)/;\nvar regExpExec = uncurryThis(nameRE.exec);\nvar NAME = 'name';\n\n// Function instances `.name` property\n// https://tc39.es/ecma262/#sec-function-instances-name\nif (DESCRIPTORS && !FUNCTION_NAME_EXISTS) {\n defineBuiltInAccessor(FunctionPrototype, NAME, {\n configurable: true,\n get: function () {\n try {\n return regExpExec(nameRE, functionToString(this))[1];\n } catch (error) {\n return '';\n }\n }\n });\n}\n","'use strict';\nvar internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.es/ecma262/#sec-object.keys\n// eslint-disable-next-line es/no-object-keys -- safe\nmodule.exports = Object.keys || function keys(O) {\n return internalObjectKeys(O, enumBugKeys);\n};\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar call = require('../internals/function-call');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\n// eslint-disable-next-line es/no-object-assign -- safe\nvar $assign = Object.assign;\n// eslint-disable-next-line es/no-object-defineproperty -- required for testing\nvar defineProperty = Object.defineProperty;\nvar concat = uncurryThis([].concat);\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\nmodule.exports = !$assign || fails(function () {\n // should have correct order of operations (Edge bug)\n if (DESCRIPTORS && $assign({ b: 1 }, $assign(defineProperty({}, 'a', {\n enumerable: true,\n get: function () {\n defineProperty(this, 'b', {\n value: 3,\n enumerable: false\n });\n }\n }), { b: 2 })).b !== 1) return true;\n // should work with symbols and should have deterministic property order (V8 bug)\n var A = {};\n var B = {};\n // eslint-disable-next-line es/no-symbol -- safe\n var symbol = Symbol('assign detection');\n var alphabet = 'abcdefghijklmnopqrst';\n A[symbol] = 7;\n alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n return $assign({}, A)[symbol] !== 7 || objectKeys($assign({}, B)).join('') !== alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars -- required for `.length`\n var T = toObject(target);\n var argumentsLength = arguments.length;\n var index = 1;\n var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n var propertyIsEnumerable = propertyIsEnumerableModule.f;\n while (argumentsLength > index) {\n var S = IndexedObject(arguments[index++]);\n var keys = getOwnPropertySymbols ? concat(objectKeys(S), getOwnPropertySymbols(S)) : objectKeys(S);\n var length = keys.length;\n var j = 0;\n var key;\n while (length > j) {\n key = keys[j++];\n if (!DESCRIPTORS || call(propertyIsEnumerable, S, key)) T[key] = S[key];\n }\n } return T;\n} : $assign;\n","'use strict';\nvar $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.es/ecma262/#sec-object.assign\n// eslint-disable-next-line es/no-object-assign -- required for testing\n$({ target: 'Object', stat: true, arity: 2, forced: Object.assign !== assign }, {\n assign: assign\n});\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n return '[object ' + classof(this) + ']';\n};\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.es/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n defineBuiltIn(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar global = require('../internals/global');\nvar classof = require('../internals/classof-raw');\n\nmodule.exports = classof(global.process) === 'process';\n","'use strict';\nvar global = require('../internals/global');\nvar apply = require('../internals/function-apply');\nvar bind = require('../internals/function-bind-context');\nvar isCallable = require('../internals/is-callable');\nvar hasOwn = require('../internals/has-own-property');\nvar fails = require('../internals/fails');\nvar html = require('../internals/html');\nvar arraySlice = require('../internals/array-slice');\nvar createElement = require('../internals/document-create-element');\nvar validateArgumentsLength = require('../internals/validate-arguments-length');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar Dispatch = global.Dispatch;\nvar Function = global.Function;\nvar MessageChannel = global.MessageChannel;\nvar String = global.String;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar $location, defer, channel, port;\n\nfails(function () {\n // Deno throws a ReferenceError on `location` access without `--location` flag\n $location = global.location;\n});\n\nvar run = function (id) {\n if (hasOwn(queue, id)) {\n var fn = queue[id];\n delete queue[id];\n fn();\n }\n};\n\nvar runner = function (id) {\n return function () {\n run(id);\n };\n};\n\nvar eventListener = function (event) {\n run(event.data);\n};\n\nvar globalPostMessageDefer = function (id) {\n // old engines have not location.origin\n global.postMessage(String(id), $location.protocol + '//' + $location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n set = function setImmediate(handler) {\n validateArgumentsLength(arguments.length, 1);\n var fn = isCallable(handler) ? handler : Function(handler);\n var args = arraySlice(arguments, 1);\n queue[++counter] = function () {\n apply(fn, undefined, args);\n };\n defer(counter);\n return counter;\n };\n clear = function clearImmediate(id) {\n delete queue[id];\n };\n // Node.js 0.8-\n if (IS_NODE) {\n defer = function (id) {\n process.nextTick(runner(id));\n };\n // Sphere (JS game engine) Dispatch API\n } else if (Dispatch && Dispatch.now) {\n defer = function (id) {\n Dispatch.now(runner(id));\n };\n // Browsers with MessageChannel, includes WebWorkers\n // except iOS - https://github.com/zloirock/core-js/issues/624\n } else if (MessageChannel && !IS_IOS) {\n channel = new MessageChannel();\n port = channel.port2;\n channel.port1.onmessage = eventListener;\n defer = bind(port.postMessage, port);\n // Browsers with postMessage, skip WebWorkers\n // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n } else if (\n global.addEventListener &&\n isCallable(global.postMessage) &&\n !global.importScripts &&\n $location && $location.protocol !== 'file:' &&\n !fails(globalPostMessageDefer)\n ) {\n defer = globalPostMessageDefer;\n global.addEventListener('message', eventListener, false);\n // IE8-\n } else if (ONREADYSTATECHANGE in createElement('script')) {\n defer = function (id) {\n html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n html.removeChild(this);\n run(id);\n };\n };\n // Rest old browsers\n } else {\n defer = function (id) {\n setTimeout(runner(id), 0);\n };\n }\n}\n\nmodule.exports = {\n set: set,\n clear: clear\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar aCallable = require('../internals/a-callable');\n\nmodule.exports = function (object, key, method) {\n try {\n // eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe\n return uncurryThis(aCallable(Object.getOwnPropertyDescriptor(object, key)[method]));\n } catch (error) { /* empty */ }\n};\n","'use strict';\nvar isCallable = require('../internals/is-callable');\n\nvar $String = String;\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument) {\n if (typeof argument == 'object' || isCallable(argument)) return argument;\n throw new $TypeError(\"Can't set \" + $String(argument) + ' as a prototype');\n};\n","'use strict';\n/* eslint-disable no-proto -- safe */\nvar uncurryThisAccessor = require('../internals/function-uncurry-this-accessor');\nvar anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n// eslint-disable-next-line es/no-object-setprototypeof -- safe\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n var CORRECT_SETTER = false;\n var test = {};\n var setter;\n try {\n setter = uncurryThisAccessor(Object.prototype, '__proto__', 'set');\n setter(test, []);\n CORRECT_SETTER = test instanceof Array;\n } catch (error) { /* empty */ }\n return function setPrototypeOf(O, proto) {\n anObject(O);\n aPossiblePrototype(proto);\n if (CORRECT_SETTER) setter(O, proto);\n else O.__proto__ = proto;\n return O;\n };\n}() : undefined);\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar hasOwn = require('../internals/has-own-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (target, TAG, STATIC) {\n if (target && !STATIC) target = target.prototype;\n if (target && !hasOwn(target, TO_STRING_TAG)) {\n defineProperty(target, TO_STRING_TAG, { configurable: true, value: TAG });\n }\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar defineBuiltInAccessor = require('../internals/define-built-in-accessor');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n\n if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n defineBuiltInAccessor(Constructor, SPECIES, {\n configurable: true,\n get: function () { return this; }\n });\n }\n};\n","'use strict';\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (it, Prototype) {\n if (isPrototypeOf(Prototype, it)) return it;\n throw new $TypeError('Incorrect invocation');\n};\n","'use strict';\nvar isConstructor = require('../internals/is-constructor');\nvar tryToString = require('../internals/try-to-string');\n\nvar $TypeError = TypeError;\n\n// `Assert: IsConstructor(argument) is true`\nmodule.exports = function (argument) {\n if (isConstructor(argument)) return argument;\n throw new $TypeError(tryToString(argument) + ' is not a constructor');\n};\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar aConstructor = require('../internals/a-constructor');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.es/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n var C = anObject(O).constructor;\n var S;\n return C === undefined || isNullOrUndefined(S = anObject(C)[SPECIES]) ? defaultConstructor : aConstructor(S);\n};\n","'use strict';\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar FunctionPrototype = Function.prototype;\nvar apply = FunctionPrototype.apply;\nvar call = FunctionPrototype.call;\n\n// eslint-disable-next-line es/no-reflect -- safe\nmodule.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {\n return call.apply(apply, arguments);\n});\n","'use strict';\nvar classofRaw = require('../internals/classof-raw');\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = function (fn) {\n // Nashorn bug:\n // https://github.com/zloirock/core-js/issues/1128\n // https://github.com/zloirock/core-js/issues/1130\n if (classofRaw(fn) === 'Function') return uncurryThis(fn);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this-clause');\nvar aCallable = require('../internals/a-callable');\nvar NATIVE_BIND = require('../internals/function-bind-native');\n\nvar bind = uncurryThis(uncurryThis.bind);\n\n// optional / simple context binding\nmodule.exports = function (fn, that) {\n aCallable(fn);\n return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\n\nmodule.exports = uncurryThis([].slice);\n","'use strict';\nvar $TypeError = TypeError;\n\nmodule.exports = function (passed, required) {\n if (passed < required) throw new $TypeError('Not enough arguments');\n return passed;\n};\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line redos/no-vulnerable -- safe\nmodule.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(userAgent);\n","'use strict';\nvar Queue = function () {\n this.head = null;\n this.tail = null;\n};\n\nQueue.prototype = {\n add: function (item) {\n var entry = { item: item, next: null };\n var tail = this.tail;\n if (tail) tail.next = entry;\n else this.head = entry;\n this.tail = entry;\n },\n get: function () {\n var entry = this.head;\n if (entry) {\n var next = this.head = entry.next;\n if (next === null) this.tail = null;\n return entry.item;\n }\n }\n};\n\nmodule.exports = Queue;\n","'use strict';\nvar global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar macrotask = require('../internals/task').set;\nvar Queue = require('../internals/queue');\nvar IS_IOS = require('../internals/engine-is-ios');\nvar IS_IOS_PEBBLE = require('../internals/engine-is-ios-pebble');\nvar IS_WEBOS_WEBKIT = require('../internals/engine-is-webos-webkit');\nvar IS_NODE = require('../internals/engine-is-node');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar document = global.document;\nvar process = global.process;\nvar Promise = global.Promise;\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar microtask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\nvar notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!microtask) {\n var queue = new Queue();\n\n var flush = function () {\n var parent, fn;\n if (IS_NODE && (parent = process.domain)) parent.exit();\n while (fn = queue.get()) try {\n fn();\n } catch (error) {\n if (queue.head) notify();\n throw error;\n }\n if (parent) parent.enter();\n };\n\n // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n // also except WebOS Webkit https://github.com/zloirock/core-js/issues/898\n if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {\n toggle = true;\n node = document.createTextNode('');\n new MutationObserver(flush).observe(node, { characterData: true });\n notify = function () {\n node.data = toggle = !toggle;\n };\n // environments with maybe non-completely correct, but existent Promise\n } else if (!IS_IOS_PEBBLE && Promise && Promise.resolve) {\n // Promise.resolve without an argument throws an error in LG WebOS 2\n promise = Promise.resolve(undefined);\n // workaround of WebKit ~ iOS Safari 10.1 bug\n promise.constructor = Promise;\n then = bind(promise.then, promise);\n notify = function () {\n then(flush);\n };\n // Node.js without promises\n } else if (IS_NODE) {\n notify = function () {\n process.nextTick(flush);\n };\n // for other environments - macrotask based on:\n // - setImmediate\n // - MessageChannel\n // - window.postMessage\n // - onreadystatechange\n // - setTimeout\n } else {\n // `webpack` dev server bug on IE global methods - use bind(fn, global)\n macrotask = bind(macrotask, global);\n notify = function () {\n macrotask(flush);\n };\n }\n\n microtask = function (fn) {\n if (!queue.head) notify();\n queue.add(fn);\n };\n}\n\nmodule.exports = microtask;\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /ipad|iphone|ipod/i.test(userAgent) && typeof Pebble != 'undefined';\n","'use strict';\nvar userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /web0s(?!.*chrome)/i.test(userAgent);\n","'use strict';\nmodule.exports = function (exec) {\n try {\n return { error: false, value: exec() };\n } catch (error) {\n return { error: true, value: error };\n }\n};\n","'use strict';\nvar global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","'use strict';\n/* global Deno -- Deno case */\nmodule.exports = typeof Deno == 'object' && Deno && typeof Deno.version == 'object';\n","'use strict';\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_NODE = require('../internals/engine-is-node');\n\nmodule.exports = !IS_DENO && !IS_NODE\n && typeof window == 'object'\n && typeof document == 'object';\n","'use strict';\nvar global = require('../internals/global');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar isCallable = require('../internals/is-callable');\nvar isForced = require('../internals/is-forced');\nvar inspectSource = require('../internals/inspect-source');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_BROWSER = require('../internals/engine-is-browser');\nvar IS_DENO = require('../internals/engine-is-deno');\nvar IS_PURE = require('../internals/is-pure');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar SPECIES = wellKnownSymbol('species');\nvar SUBCLASSING = false;\nvar NATIVE_PROMISE_REJECTION_EVENT = isCallable(global.PromiseRejectionEvent);\n\nvar FORCED_PROMISE_CONSTRUCTOR = isForced('Promise', function () {\n var PROMISE_CONSTRUCTOR_SOURCE = inspectSource(NativePromiseConstructor);\n var GLOBAL_CORE_JS_PROMISE = PROMISE_CONSTRUCTOR_SOURCE !== String(NativePromiseConstructor);\n // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n // We can't detect it synchronously, so just check versions\n if (!GLOBAL_CORE_JS_PROMISE && V8_VERSION === 66) return true;\n // We need Promise#{ catch, finally } in the pure version for preventing prototype pollution\n if (IS_PURE && !(NativePromisePrototype['catch'] && NativePromisePrototype['finally'])) return true;\n // We can't use @@species feature detection in V8 since it causes\n // deoptimization and performance degradation\n // https://github.com/zloirock/core-js/issues/679\n if (!V8_VERSION || V8_VERSION < 51 || !/native code/.test(PROMISE_CONSTRUCTOR_SOURCE)) {\n // Detect correctness of subclassing with @@species support\n var promise = new NativePromiseConstructor(function (resolve) { resolve(1); });\n var FakePromise = function (exec) {\n exec(function () { /* empty */ }, function () { /* empty */ });\n };\n var constructor = promise.constructor = {};\n constructor[SPECIES] = FakePromise;\n SUBCLASSING = promise.then(function () { /* empty */ }) instanceof FakePromise;\n if (!SUBCLASSING) return true;\n // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n } return !GLOBAL_CORE_JS_PROMISE && (IS_BROWSER || IS_DENO) && !NATIVE_PROMISE_REJECTION_EVENT;\n});\n\nmodule.exports = {\n CONSTRUCTOR: FORCED_PROMISE_CONSTRUCTOR,\n REJECTION_EVENT: NATIVE_PROMISE_REJECTION_EVENT,\n SUBCLASSING: SUBCLASSING\n};\n","'use strict';\nvar aCallable = require('../internals/a-callable');\n\nvar $TypeError = TypeError;\n\nvar PromiseCapability = function (C) {\n var resolve, reject;\n this.promise = new C(function ($$resolve, $$reject) {\n if (resolve !== undefined || reject !== undefined) throw new $TypeError('Bad Promise constructor');\n resolve = $$resolve;\n reject = $$reject;\n });\n this.resolve = aCallable(resolve);\n this.reject = aCallable(reject);\n};\n\n// `NewPromiseCapability` abstract operation\n// https://tc39.es/ecma262/#sec-newpromisecapability\nmodule.exports.f = function (C) {\n return new PromiseCapability(C);\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar IS_NODE = require('../internals/engine-is-node');\nvar global = require('../internals/global');\nvar call = require('../internals/function-call');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar aCallable = require('../internals/a-callable');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar perform = require('../internals/perform');\nvar Queue = require('../internals/queue');\nvar InternalStateModule = require('../internals/internal-state');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar PromiseConstructorDetection = require('../internals/promise-constructor-detection');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\n\nvar PROMISE = 'Promise';\nvar FORCED_PROMISE_CONSTRUCTOR = PromiseConstructorDetection.CONSTRUCTOR;\nvar NATIVE_PROMISE_REJECTION_EVENT = PromiseConstructorDetection.REJECTION_EVENT;\nvar NATIVE_PROMISE_SUBCLASSING = PromiseConstructorDetection.SUBCLASSING;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar setInternalState = InternalStateModule.set;\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\nvar PromiseConstructor = NativePromiseConstructor;\nvar PromisePrototype = NativePromisePrototype;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\n\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\n\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\n// helpers\nvar isThenable = function (it) {\n var then;\n return isObject(it) && isCallable(then = it.then) ? then : false;\n};\n\nvar callReaction = function (reaction, state) {\n var value = state.value;\n var ok = state.state === FULFILLED;\n var handler = ok ? reaction.ok : reaction.fail;\n var resolve = reaction.resolve;\n var reject = reaction.reject;\n var domain = reaction.domain;\n var result, then, exited;\n try {\n if (handler) {\n if (!ok) {\n if (state.rejection === UNHANDLED) onHandleUnhandled(state);\n state.rejection = HANDLED;\n }\n if (handler === true) result = value;\n else {\n if (domain) domain.enter();\n result = handler(value); // can throw\n if (domain) {\n domain.exit();\n exited = true;\n }\n }\n if (result === reaction.promise) {\n reject(new TypeError('Promise-chain cycle'));\n } else if (then = isThenable(result)) {\n call(then, result, resolve, reject);\n } else resolve(result);\n } else reject(value);\n } catch (error) {\n if (domain && !exited) domain.exit();\n reject(error);\n }\n};\n\nvar notify = function (state, isReject) {\n if (state.notified) return;\n state.notified = true;\n microtask(function () {\n var reactions = state.reactions;\n var reaction;\n while (reaction = reactions.get()) {\n callReaction(reaction, state);\n }\n state.notified = false;\n if (isReject && !state.rejection) onUnhandled(state);\n });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n var event, handler;\n if (DISPATCH_EVENT) {\n event = document.createEvent('Event');\n event.promise = promise;\n event.reason = reason;\n event.initEvent(name, false, true);\n global.dispatchEvent(event);\n } else event = { promise: promise, reason: reason };\n if (!NATIVE_PROMISE_REJECTION_EVENT && (handler = global['on' + name])) handler(event);\n else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n var value = state.value;\n var IS_UNHANDLED = isUnhandled(state);\n var result;\n if (IS_UNHANDLED) {\n result = perform(function () {\n if (IS_NODE) {\n process.emit('unhandledRejection', value, promise);\n } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n });\n // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n if (result.error) throw result.value;\n }\n });\n};\n\nvar isUnhandled = function (state) {\n return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (state) {\n call(task, global, function () {\n var promise = state.facade;\n if (IS_NODE) {\n process.emit('rejectionHandled', promise);\n } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n });\n};\n\nvar bind = function (fn, state, unwrap) {\n return function (value) {\n fn(state, value, unwrap);\n };\n};\n\nvar internalReject = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n state.value = value;\n state.state = REJECTED;\n notify(state, true);\n};\n\nvar internalResolve = function (state, value, unwrap) {\n if (state.done) return;\n state.done = true;\n if (unwrap) state = unwrap;\n try {\n if (state.facade === value) throw new TypeError(\"Promise can't be resolved itself\");\n var then = isThenable(value);\n if (then) {\n microtask(function () {\n var wrapper = { done: false };\n try {\n call(then, value,\n bind(internalResolve, wrapper, state),\n bind(internalReject, wrapper, state)\n );\n } catch (error) {\n internalReject(wrapper, error, state);\n }\n });\n } else {\n state.value = value;\n state.state = FULFILLED;\n notify(state, false);\n }\n } catch (error) {\n internalReject({ done: false }, error, state);\n }\n};\n\n// constructor polyfill\nif (FORCED_PROMISE_CONSTRUCTOR) {\n // 25.4.3.1 Promise(executor)\n PromiseConstructor = function Promise(executor) {\n anInstance(this, PromisePrototype);\n aCallable(executor);\n call(Internal, this);\n var state = getInternalPromiseState(this);\n try {\n executor(bind(internalResolve, state), bind(internalReject, state));\n } catch (error) {\n internalReject(state, error);\n }\n };\n\n PromisePrototype = PromiseConstructor.prototype;\n\n // eslint-disable-next-line no-unused-vars -- required for `.length`\n Internal = function Promise(executor) {\n setInternalState(this, {\n type: PROMISE,\n done: false,\n notified: false,\n parent: false,\n reactions: new Queue(),\n rejection: false,\n state: PENDING,\n value: undefined\n });\n };\n\n // `Promise.prototype.then` method\n // https://tc39.es/ecma262/#sec-promise.prototype.then\n Internal.prototype = defineBuiltIn(PromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var state = getInternalPromiseState(this);\n var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n state.parent = true;\n reaction.ok = isCallable(onFulfilled) ? onFulfilled : true;\n reaction.fail = isCallable(onRejected) && onRejected;\n reaction.domain = IS_NODE ? process.domain : undefined;\n if (state.state === PENDING) state.reactions.add(reaction);\n else microtask(function () {\n callReaction(reaction, state);\n });\n return reaction.promise;\n });\n\n OwnPromiseCapability = function () {\n var promise = new Internal();\n var state = getInternalPromiseState(promise);\n this.promise = promise;\n this.resolve = bind(internalResolve, state);\n this.reject = bind(internalReject, state);\n };\n\n newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n return C === PromiseConstructor || C === PromiseWrapper\n ? new OwnPromiseCapability(C)\n : newGenericPromiseCapability(C);\n };\n\n if (!IS_PURE && isCallable(NativePromiseConstructor) && NativePromisePrototype !== Object.prototype) {\n nativeThen = NativePromisePrototype.then;\n\n if (!NATIVE_PROMISE_SUBCLASSING) {\n // make `Promise#then` return a polyfilled `Promise` for native promise-based APIs\n defineBuiltIn(NativePromisePrototype, 'then', function then(onFulfilled, onRejected) {\n var that = this;\n return new PromiseConstructor(function (resolve, reject) {\n call(nativeThen, that, resolve, reject);\n }).then(onFulfilled, onRejected);\n // https://github.com/zloirock/core-js/issues/640\n }, { unsafe: true });\n }\n\n // make `.constructor === Promise` work for native promise-based APIs\n try {\n delete NativePromisePrototype.constructor;\n } catch (error) { /* empty */ }\n\n // make `instanceof Promise` work for native promise-based APIs\n if (setPrototypeOf) {\n setPrototypeOf(NativePromisePrototype, PromisePrototype);\n }\n }\n}\n\n$({ global: true, constructor: true, wrap: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n","'use strict';\nmodule.exports = function (a, b) {\n try {\n // eslint-disable-next-line no-console -- safe\n arguments.length === 1 ? console.error(a) : console.error(a, b);\n } catch (error) { /* empty */ }\n};\n","'use strict';\nmodule.exports = {};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar classof = require('../internals/classof');\nvar getMethod = require('../internals/get-method');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)\n || getMethod(it, '@@iterator')\n || Iterators[classof(it)];\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nvar $TypeError = TypeError;\n\nmodule.exports = function (argument, usingIterator) {\n var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;\n if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));\n throw new $TypeError(tryToString(argument) + ' is not iterable');\n};\n","'use strict';\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar getMethod = require('../internals/get-method');\n\nmodule.exports = function (iterator, kind, value) {\n var innerResult, innerError;\n anObject(iterator);\n try {\n innerResult = getMethod(iterator, 'return');\n if (!innerResult) {\n if (kind === 'throw') throw value;\n return value;\n }\n innerResult = call(innerResult, iterator);\n } catch (error) {\n innerError = true;\n innerResult = error;\n }\n if (kind === 'throw') throw value;\n if (innerError) throw innerResult;\n anObject(innerResult);\n return value;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar call = require('../internals/function-call');\nvar anObject = require('../internals/an-object');\nvar tryToString = require('../internals/try-to-string');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar isPrototypeOf = require('../internals/object-is-prototype-of');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar iteratorClose = require('../internals/iterator-close');\n\nvar $TypeError = TypeError;\n\nvar Result = function (stopped, result) {\n this.stopped = stopped;\n this.result = result;\n};\n\nvar ResultPrototype = Result.prototype;\n\nmodule.exports = function (iterable, unboundFunction, options) {\n var that = options && options.that;\n var AS_ENTRIES = !!(options && options.AS_ENTRIES);\n var IS_RECORD = !!(options && options.IS_RECORD);\n var IS_ITERATOR = !!(options && options.IS_ITERATOR);\n var INTERRUPTED = !!(options && options.INTERRUPTED);\n var fn = bind(unboundFunction, that);\n var iterator, iterFn, index, length, result, next, step;\n\n var stop = function (condition) {\n if (iterator) iteratorClose(iterator, 'normal', condition);\n return new Result(true, condition);\n };\n\n var callFn = function (value) {\n if (AS_ENTRIES) {\n anObject(value);\n return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);\n } return INTERRUPTED ? fn(value, stop) : fn(value);\n };\n\n if (IS_RECORD) {\n iterator = iterable.iterator;\n } else if (IS_ITERATOR) {\n iterator = iterable;\n } else {\n iterFn = getIteratorMethod(iterable);\n if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');\n // optimisation for array iterators\n if (isArrayIteratorMethod(iterFn)) {\n for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {\n result = callFn(iterable[index]);\n if (result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n }\n iterator = getIterator(iterable, iterFn);\n }\n\n next = IS_RECORD ? iterable.next : iterator.next;\n while (!(step = call(next, iterator)).done) {\n try {\n result = callFn(step.value);\n } catch (error) {\n iteratorClose(iterator, 'throw', error);\n }\n if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;\n } return new Result(false);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n var called = 0;\n var iteratorWithReturn = {\n next: function () {\n return { done: !!called++ };\n },\n 'return': function () {\n SAFE_CLOSING = true;\n }\n };\n iteratorWithReturn[ITERATOR] = function () {\n return this;\n };\n // eslint-disable-next-line es/no-array-from, no-throw-literal -- required for testing\n Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n try {\n if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n } catch (error) { return false; } // workaround of old WebKit + `eval` bug\n var ITERATION_SUPPORT = false;\n try {\n var object = {};\n object[ITERATOR] = function () {\n return {\n next: function () {\n return { done: ITERATION_SUPPORT = true };\n }\n };\n };\n exec(object);\n } catch (error) { /* empty */ }\n return ITERATION_SUPPORT;\n};\n","'use strict';\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\nmodule.exports = FORCED_PROMISE_CONSTRUCTOR || !checkCorrectnessOfIteration(function (iterable) {\n NativePromiseConstructor.all(iterable).then(undefined, function () { /* empty */ });\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.all` method\n// https://tc39.es/ecma262/#sec-promise.all\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n all: function all(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var resolve = capability.resolve;\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n var values = [];\n var counter = 0;\n var remaining = 1;\n iterate(iterable, function (promise) {\n var index = counter++;\n var alreadyCalled = false;\n remaining++;\n call($promiseResolve, C, promise).then(function (value) {\n if (alreadyCalled) return;\n alreadyCalled = true;\n values[index] = value;\n --remaining || resolve(values);\n }, reject);\n });\n --remaining || resolve(values);\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar getBuiltIn = require('../internals/get-built-in');\nvar isCallable = require('../internals/is-callable');\nvar defineBuiltIn = require('../internals/define-built-in');\n\nvar NativePromisePrototype = NativePromiseConstructor && NativePromiseConstructor.prototype;\n\n// `Promise.prototype.catch` method\n// https://tc39.es/ecma262/#sec-promise.prototype.catch\n$({ target: 'Promise', proto: true, forced: FORCED_PROMISE_CONSTRUCTOR, real: true }, {\n 'catch': function (onRejected) {\n return this.then(undefined, onRejected);\n }\n});\n\n// makes sure that native promise-based APIs `Promise#catch` properly works with patched `Promise#then`\nif (!IS_PURE && isCallable(NativePromiseConstructor)) {\n var method = getBuiltIn('Promise').prototype['catch'];\n if (NativePromisePrototype['catch'] !== method) {\n defineBuiltIn(NativePromisePrototype, 'catch', method, { unsafe: true });\n }\n}\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar aCallable = require('../internals/a-callable');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\nvar PROMISE_STATICS_INCORRECT_ITERATION = require('../internals/promise-statics-incorrect-iteration');\n\n// `Promise.race` method\n// https://tc39.es/ecma262/#sec-promise.race\n$({ target: 'Promise', stat: true, forced: PROMISE_STATICS_INCORRECT_ITERATION }, {\n race: function race(iterable) {\n var C = this;\n var capability = newPromiseCapabilityModule.f(C);\n var reject = capability.reject;\n var result = perform(function () {\n var $promiseResolve = aCallable(C.resolve);\n iterate(iterable, function (promise) {\n call($promiseResolve, C, promise).then(capability.resolve, reject);\n });\n });\n if (result.error) reject(result.value);\n return capability.promise;\n }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\n\n// `Promise.reject` method\n// https://tc39.es/ecma262/#sec-promise.reject\n$({ target: 'Promise', stat: true, forced: FORCED_PROMISE_CONSTRUCTOR }, {\n reject: function reject(r) {\n var capability = newPromiseCapabilityModule.f(this);\n call(capability.reject, undefined, r);\n return capability.promise;\n }\n});\n","'use strict';\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n anObject(C);\n if (isObject(x) && x.constructor === C) return x;\n var promiseCapability = newPromiseCapability.f(C);\n var resolve = promiseCapability.resolve;\n resolve(x);\n return promiseCapability.promise;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromiseConstructor = require('../internals/promise-native-constructor');\nvar FORCED_PROMISE_CONSTRUCTOR = require('../internals/promise-constructor-detection').CONSTRUCTOR;\nvar promiseResolve = require('../internals/promise-resolve');\n\nvar PromiseConstructorWrapper = getBuiltIn('Promise');\nvar CHECK_WRAPPER = IS_PURE && !FORCED_PROMISE_CONSTRUCTOR;\n\n// `Promise.resolve` method\n// https://tc39.es/ecma262/#sec-promise.resolve\n$({ target: 'Promise', stat: true, forced: IS_PURE || FORCED_PROMISE_CONSTRUCTOR }, {\n resolve: function resolve(x) {\n return promiseResolve(CHECK_WRAPPER && this === PromiseConstructorWrapper ? NativePromiseConstructor : this, x);\n }\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar V8_PROTOTYPE_DEFINE_BUG = require('../internals/v8-prototype-define-bug');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.es/ecma262/#sec-object.defineproperties\n// eslint-disable-next-line es/no-object-defineproperties -- safe\nexports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {\n anObject(O);\n var props = toIndexedObject(Properties);\n var keys = objectKeys(Properties);\n var length = keys.length;\n var index = 0;\n var key;\n while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);\n return O;\n};\n","'use strict';\n/* global ActiveXObject -- old IE, WSH */\nvar anObject = require('../internals/an-object');\nvar definePropertiesModule = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n activeXDocument.write(scriptTag(''));\n activeXDocument.close();\n var temp = activeXDocument.parentWindow.Object;\n activeXDocument = null; // avoid memory leak\n return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n // Thrash, waste and sodomy: IE GC bug\n var iframe = documentCreateElement('iframe');\n var JS = 'java' + SCRIPT + ':';\n var iframeDocument;\n iframe.style.display = 'none';\n html.appendChild(iframe);\n // https://github.com/zloirock/core-js/issues/475\n iframe.src = String(JS);\n iframeDocument = iframe.contentWindow.document;\n iframeDocument.open();\n iframeDocument.write(scriptTag('document.F=Object'));\n iframeDocument.close();\n return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n try {\n activeXDocument = new ActiveXObject('htmlfile');\n } catch (error) { /* ignore */ }\n NullProtoObject = typeof document != 'undefined'\n ? document.domain && activeXDocument\n ? NullProtoObjectViaActiveX(activeXDocument) // old IE\n : NullProtoObjectViaIFrame()\n : NullProtoObjectViaActiveX(activeXDocument); // WSH\n var length = enumBugKeys.length;\n while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.es/ecma262/#sec-object.create\n// eslint-disable-next-line es/no-object-create -- safe\nmodule.exports = Object.create || function create(O, Properties) {\n var result;\n if (O !== null) {\n EmptyConstructor[PROTOTYPE] = anObject(O);\n result = new EmptyConstructor();\n EmptyConstructor[PROTOTYPE] = null;\n // add \"__proto__\" for Object.getPrototypeOf polyfill\n result[IE_PROTO] = O;\n } else result = NullProtoObject();\n return Properties === undefined ? result : definePropertiesModule.f(result, Properties);\n};\n","'use strict';\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar defineProperty = require('../internals/object-define-property').f;\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] === undefined) {\n defineProperty(ArrayPrototype, UNSCOPABLES, {\n configurable: true,\n value: create(null)\n });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","'use strict';\nvar fails = require('../internals/fails');\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\n// `%IteratorPrototype%` object\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\n/* eslint-disable es/no-array-prototype-keys -- safe */\nif ([].keys) {\n arrayIterator = [].keys();\n // Safari 8 has buggy iterators w/o `next`\n if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n else {\n PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n }\n}\n\nvar NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {\n var test = {};\n // FF44- legacy iterators case\n return IteratorPrototype[ITERATOR].call(test) !== test;\n});\n\nif (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};\nelse if (IS_PURE) IteratorPrototype = create(IteratorPrototype);\n\n// `%IteratorPrototype%[@@iterator]()` method\n// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator\nif (!isCallable(IteratorPrototype[ITERATOR])) {\n defineBuiltIn(IteratorPrototype, ITERATOR, function () {\n return this;\n });\n}\n\nmodule.exports = {\n IteratorPrototype: IteratorPrototype,\n BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n function F() { /* empty */ }\n F.prototype.constructor = null;\n // eslint-disable-next-line es/no-object-getprototypeof -- required for testing\n return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","'use strict';\nvar hasOwn = require('../internals/has-own-property');\nvar isCallable = require('../internals/is-callable');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar $Object = Object;\nvar ObjectPrototype = $Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.es/ecma262/#sec-object.getprototypeof\n// eslint-disable-next-line es/no-object-getprototypeof -- safe\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {\n var object = toObject(O);\n if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];\n var constructor = object.constructor;\n if (isCallable(constructor) && object instanceof constructor) {\n return constructor.prototype;\n } return object instanceof $Object ? ObjectPrototype : null;\n};\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next, ENUMERABLE_NEXT) {\n var TO_STRING_TAG = NAME + ' Iterator';\n IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(+!ENUMERABLE_NEXT, next) });\n setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n Iterators[TO_STRING_TAG] = returnThis;\n return IteratorConstructor;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar call = require('../internals/function-call');\nvar IS_PURE = require('../internals/is-pure');\nvar FunctionName = require('../internals/function-name');\nvar isCallable = require('../internals/is-callable');\nvar createIteratorConstructor = require('../internals/iterator-create-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar PROPER_FUNCTION_NAME = FunctionName.PROPER;\nvar CONFIGURABLE_FUNCTION_NAME = FunctionName.CONFIGURABLE;\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n createIteratorConstructor(IteratorConstructor, NAME, next);\n\n var getIterationMethod = function (KIND) {\n if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n if (!BUGGY_SAFARI_ITERATORS && KIND && KIND in IterablePrototype) return IterablePrototype[KIND];\n\n switch (KIND) {\n case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n }\n\n return function () { return new IteratorConstructor(this); };\n };\n\n var TO_STRING_TAG = NAME + ' Iterator';\n var INCORRECT_VALUES_NAME = false;\n var IterablePrototype = Iterable.prototype;\n var nativeIterator = IterablePrototype[ITERATOR]\n || IterablePrototype['@@iterator']\n || DEFAULT && IterablePrototype[DEFAULT];\n var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n var anyNativeIterator = NAME === 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n var CurrentIteratorPrototype, methods, KEY;\n\n // fix native\n if (anyNativeIterator) {\n CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n if (CurrentIteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n if (setPrototypeOf) {\n setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n } else if (!isCallable(CurrentIteratorPrototype[ITERATOR])) {\n defineBuiltIn(CurrentIteratorPrototype, ITERATOR, returnThis);\n }\n }\n // Set @@toStringTag to native iterators\n setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n }\n }\n\n // fix Array.prototype.{ values, @@iterator }.name in V8 / FF\n if (PROPER_FUNCTION_NAME && DEFAULT === VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n if (!IS_PURE && CONFIGURABLE_FUNCTION_NAME) {\n createNonEnumerableProperty(IterablePrototype, 'name', VALUES);\n } else {\n INCORRECT_VALUES_NAME = true;\n defaultIterator = function values() { return call(nativeIterator, this); };\n }\n }\n\n // export additional methods\n if (DEFAULT) {\n methods = {\n values: getIterationMethod(VALUES),\n keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n entries: getIterationMethod(ENTRIES)\n };\n if (FORCED) for (KEY in methods) {\n if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n defineBuiltIn(IterablePrototype, KEY, methods[KEY]);\n }\n } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n }\n\n // define iterator\n if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n defineBuiltIn(IterablePrototype, ITERATOR, defaultIterator, { name: DEFAULT });\n }\n Iterators[NAME] = defaultIterator;\n\n return methods;\n};\n","'use strict';\n// `CreateIterResultObject` abstract operation\n// https://tc39.es/ecma262/#sec-createiterresultobject\nmodule.exports = function (value, done) {\n return { value: value, done: done };\n};\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineProperty = require('../internals/object-define-property').f;\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\nvar IS_PURE = require('../internals/is-pure');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.es/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.es/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.es/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.es/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n setInternalState(this, {\n type: ARRAY_ITERATOR,\n target: toIndexedObject(iterated), // target\n index: 0, // next index\n kind: kind // kind\n });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n var state = getInternalState(this);\n var target = state.target;\n var index = state.index++;\n if (!target || index >= target.length) {\n state.target = undefined;\n return createIterResultObject(undefined, true);\n }\n switch (state.kind) {\n case 'keys': return createIterResultObject(index, false);\n case 'values': return createIterResultObject(target[index], false);\n } return createIterResultObject([index, target[index]], false);\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.es/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.es/ecma262/#sec-createmappedargumentsobject\nvar values = Iterators.Arguments = Iterators.Array;\n\n// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n\n// V8 ~ Chrome 45- bug\nif (!IS_PURE && DESCRIPTORS && values.name !== 'values') try {\n defineProperty(values, 'name', { value: 'values' });\n} catch (error) { /* empty */ }\n","'use strict';\nvar classof = require('../internals/classof');\n\nvar $String = String;\n\nmodule.exports = function (argument) {\n if (classof(argument) === 'Symbol') throw new TypeError('Cannot convert a Symbol value to a string');\n return $String(argument);\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar toIntegerOrInfinity = require('../internals/to-integer-or-infinity');\nvar toString = require('../internals/to-string');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar charAt = uncurryThis(''.charAt);\nvar charCodeAt = uncurryThis(''.charCodeAt);\nvar stringSlice = uncurryThis(''.slice);\n\nvar createMethod = function (CONVERT_TO_STRING) {\n return function ($this, pos) {\n var S = toString(requireObjectCoercible($this));\n var position = toIntegerOrInfinity(pos);\n var size = S.length;\n var first, second;\n if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n first = charCodeAt(S, position);\n return first < 0xD800 || first > 0xDBFF || position + 1 === size\n || (second = charCodeAt(S, position + 1)) < 0xDC00 || second > 0xDFFF\n ? CONVERT_TO_STRING\n ? charAt(S, position)\n : first\n : CONVERT_TO_STRING\n ? stringSlice(S, position, position + 2)\n : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n };\n};\n\nmodule.exports = {\n // `String.prototype.codePointAt` method\n // https://tc39.es/ecma262/#sec-string.prototype.codepointat\n codeAt: createMethod(false),\n // `String.prototype.at` method\n // https://github.com/mathiasbynens/String.prototype.at\n charAt: createMethod(true)\n};\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar toString = require('../internals/to-string');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/iterator-define');\nvar createIterResultObject = require('../internals/create-iter-result-object');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.es/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n setInternalState(this, {\n type: STRING_ITERATOR,\n string: toString(iterated),\n index: 0\n });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.es/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n var state = getInternalState(this);\n var string = state.string;\n var index = state.index;\n var point;\n if (index >= string.length) return createIterResultObject(undefined, true);\n point = charAt(string, index);\n state.index += point.length;\n return createIterResultObject(point, false);\n});\n","'use strict';\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar createProperty = require('../internals/create-property');\n\nvar $Array = Array;\nvar max = Math.max;\n\nmodule.exports = function (O, start, end) {\n var length = lengthOfArrayLike(O);\n var k = toAbsoluteIndex(start, length);\n var fin = toAbsoluteIndex(end === undefined ? length : end, length);\n var result = $Array(max(fin - k, 0));\n var n = 0;\n for (; k < fin; k++, n++) createProperty(result, n, O[k]);\n result.length = n;\n return result;\n};\n","'use strict';\n/* eslint-disable es/no-object-getownpropertynames -- safe */\nvar classof = require('../internals/classof-raw');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar $getOwnPropertyNames = require('../internals/object-get-own-property-names').f;\nvar arraySlice = require('../internals/array-slice-simple');\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n try {\n return $getOwnPropertyNames(it);\n } catch (error) {\n return arraySlice(windowNames);\n }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n return windowNames && classof(it) === 'Window'\n ? getWindowNames(it)\n : $getOwnPropertyNames(toIndexedObject(it));\n};\n","'use strict';\n// FF26- bug: ArrayBuffers are non-extensible, but Object.isExtensible does not report it\nvar fails = require('../internals/fails');\n\nmodule.exports = fails(function () {\n if (typeof ArrayBuffer == 'function') {\n var buffer = new ArrayBuffer(8);\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-defineproperty -- safe\n if (Object.isExtensible(buffer)) Object.defineProperty(buffer, 'a', { value: 8 });\n }\n});\n","'use strict';\nvar fails = require('../internals/fails');\nvar isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar ARRAY_BUFFER_NON_EXTENSIBLE = require('../internals/array-buffer-non-extensible');\n\n// eslint-disable-next-line es/no-object-isextensible -- safe\nvar $isExtensible = Object.isExtensible;\nvar FAILS_ON_PRIMITIVES = fails(function () { $isExtensible(1); });\n\n// `Object.isExtensible` method\n// https://tc39.es/ecma262/#sec-object.isextensible\nmodule.exports = (FAILS_ON_PRIMITIVES || ARRAY_BUFFER_NON_EXTENSIBLE) ? function isExtensible(it) {\n if (!isObject(it)) return false;\n if (ARRAY_BUFFER_NON_EXTENSIBLE && classof(it) === 'ArrayBuffer') return false;\n return $isExtensible ? $isExtensible(it) : true;\n} : $isExtensible;\n","'use strict';\nvar fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n // eslint-disable-next-line es/no-object-isextensible, es/no-object-preventextensions -- required for testing\n return Object.isExtensible(Object.preventExtensions({}));\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar hasOwn = require('../internals/has-own-property');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternalModule = require('../internals/object-get-own-property-names-external');\nvar isExtensible = require('../internals/object-is-extensible');\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar REQUIRED = false;\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar setMetadata = function (it) {\n defineProperty(it, METADATA, { value: {\n objectID: 'O' + id++, // object ID\n weakData: {} // weak collections IDs\n } });\n};\n\nvar fastKey = function (it, create) {\n // return a primitive with prefix\n if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return 'F';\n // not necessary to add metadata\n if (!create) return 'E';\n // add missing metadata\n setMetadata(it);\n // return object ID\n } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n if (!hasOwn(it, METADATA)) {\n // can't set metadata to uncaught frozen object\n if (!isExtensible(it)) return true;\n // not necessary to add metadata\n if (!create) return false;\n // add missing metadata\n setMetadata(it);\n // return the store of weak collections IDs\n } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n if (FREEZING && REQUIRED && isExtensible(it) && !hasOwn(it, METADATA)) setMetadata(it);\n return it;\n};\n\nvar enable = function () {\n meta.enable = function () { /* empty */ };\n REQUIRED = true;\n var getOwnPropertyNames = getOwnPropertyNamesModule.f;\n var splice = uncurryThis([].splice);\n var test = {};\n test[METADATA] = 1;\n\n // prevent exposing of metadata key\n if (getOwnPropertyNames(test).length) {\n getOwnPropertyNamesModule.f = function (it) {\n var result = getOwnPropertyNames(it);\n for (var i = 0, length = result.length; i < length; i++) {\n if (result[i] === METADATA) {\n splice(result, i, 1);\n break;\n }\n } return result;\n };\n\n $({ target: 'Object', stat: true, forced: true }, {\n getOwnPropertyNames: getOwnPropertyNamesExternalModule.f\n });\n }\n};\n\nvar meta = module.exports = {\n enable: enable,\n fastKey: fastKey,\n getWeakData: getWeakData,\n onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","'use strict';\nvar isCallable = require('../internals/is-callable');\nvar isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n var NewTarget, NewTargetPrototype;\n if (\n // it can work only with native `setPrototypeOf`\n setPrototypeOf &&\n // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n isCallable(NewTarget = dummy.constructor) &&\n NewTarget !== Wrapper &&\n isObject(NewTargetPrototype = NewTarget.prototype) &&\n NewTargetPrototype !== Wrapper.prototype\n ) setPrototypeOf($this, NewTargetPrototype);\n return $this;\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar isForced = require('../internals/is-forced');\nvar defineBuiltIn = require('../internals/define-built-in');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isCallable = require('../internals/is-callable');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n var ADDER = IS_MAP ? 'set' : 'add';\n var NativeConstructor = global[CONSTRUCTOR_NAME];\n var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n var Constructor = NativeConstructor;\n var exported = {};\n\n var fixMethod = function (KEY) {\n var uncurriedNativeMethod = uncurryThis(NativePrototype[KEY]);\n defineBuiltIn(NativePrototype, KEY,\n KEY === 'add' ? function add(value) {\n uncurriedNativeMethod(this, value === 0 ? 0 : value);\n return this;\n } : KEY === 'delete' ? function (key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'get' ? function get(key) {\n return IS_WEAK && !isObject(key) ? undefined : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : KEY === 'has' ? function has(key) {\n return IS_WEAK && !isObject(key) ? false : uncurriedNativeMethod(this, key === 0 ? 0 : key);\n } : function set(key, value) {\n uncurriedNativeMethod(this, key === 0 ? 0 : key, value);\n return this;\n }\n );\n };\n\n var REPLACE = isForced(\n CONSTRUCTOR_NAME,\n !isCallable(NativeConstructor) || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n new NativeConstructor().entries().next();\n }))\n );\n\n if (REPLACE) {\n // create collection constructor\n Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n InternalMetadataModule.enable();\n } else if (isForced(CONSTRUCTOR_NAME, true)) {\n var instance = new Constructor();\n // early implementations not supports chaining\n var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) !== instance;\n // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n // most early implementations doesn't supports iterables, most modern - not close it correctly\n // eslint-disable-next-line no-new -- required for testing\n var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n // for early implementations -0 and +0 not the same\n var BUGGY_ZERO = !IS_WEAK && fails(function () {\n // V8 ~ Chromium 42- fails only with 5+ elements\n var $instance = new NativeConstructor();\n var index = 5;\n while (index--) $instance[ADDER](index, index);\n return !$instance.has(-0);\n });\n\n if (!ACCEPT_ITERABLES) {\n Constructor = wrapper(function (dummy, iterable) {\n anInstance(dummy, NativePrototype);\n var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n return that;\n });\n Constructor.prototype = NativePrototype;\n NativePrototype.constructor = Constructor;\n }\n\n if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n fixMethod('delete');\n fixMethod('has');\n IS_MAP && fixMethod('get');\n }\n\n if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n // weak collections should not contains .clear method\n if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n }\n\n exported[CONSTRUCTOR_NAME] = Constructor;\n $({ global: true, constructor: true, forced: Constructor !== NativeConstructor }, exported);\n\n setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n return Constructor;\n};\n","'use strict';\nvar defineBuiltIn = require('../internals/define-built-in');\n\nmodule.exports = function (target, src, options) {\n for (var key in src) defineBuiltIn(target, key, src[key], options);\n return target;\n};\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar lengthOfArrayLike = require('../internals/length-of-array-like');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = uncurryThis([].push);\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex, filterReject }` methods implementation\nvar createMethod = function (TYPE) {\n var IS_MAP = TYPE === 1;\n var IS_FILTER = TYPE === 2;\n var IS_SOME = TYPE === 3;\n var IS_EVERY = TYPE === 4;\n var IS_FIND_INDEX = TYPE === 6;\n var IS_FILTER_REJECT = TYPE === 7;\n var NO_HOLES = TYPE === 5 || IS_FIND_INDEX;\n return function ($this, callbackfn, that, specificCreate) {\n var O = toObject($this);\n var self = IndexedObject(O);\n var length = lengthOfArrayLike(self);\n var boundFunction = bind(callbackfn, that);\n var index = 0;\n var create = specificCreate || arraySpeciesCreate;\n var target = IS_MAP ? create($this, length) : IS_FILTER || IS_FILTER_REJECT ? create($this, 0) : undefined;\n var value, result;\n for (;length > index; index++) if (NO_HOLES || index in self) {\n value = self[index];\n result = boundFunction(value, index, O);\n if (TYPE) {\n if (IS_MAP) target[index] = result; // map\n else if (result) switch (TYPE) {\n case 3: return true; // some\n case 5: return value; // find\n case 6: return index; // findIndex\n case 2: push(target, value); // filter\n } else switch (TYPE) {\n case 4: return false; // every\n case 7: push(target, value); // filterReject\n }\n }\n }\n return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n };\n};\n\nmodule.exports = {\n // `Array.prototype.forEach` method\n // https://tc39.es/ecma262/#sec-array.prototype.foreach\n forEach: createMethod(0),\n // `Array.prototype.map` method\n // https://tc39.es/ecma262/#sec-array.prototype.map\n map: createMethod(1),\n // `Array.prototype.filter` method\n // https://tc39.es/ecma262/#sec-array.prototype.filter\n filter: createMethod(2),\n // `Array.prototype.some` method\n // https://tc39.es/ecma262/#sec-array.prototype.some\n some: createMethod(3),\n // `Array.prototype.every` method\n // https://tc39.es/ecma262/#sec-array.prototype.every\n every: createMethod(4),\n // `Array.prototype.find` method\n // https://tc39.es/ecma262/#sec-array.prototype.find\n find: createMethod(5),\n // `Array.prototype.findIndex` method\n // https://tc39.es/ecma262/#sec-array.prototype.findIndex\n findIndex: createMethod(6),\n // `Array.prototype.filterReject` method\n // https://github.com/tc39/proposal-array-filtering\n filterReject: createMethod(7)\n};\n","'use strict';\nvar uncurryThis = require('../internals/function-uncurry-this');\nvar defineBuiltIns = require('../internals/define-built-ins');\nvar getWeakData = require('../internals/internal-metadata').getWeakData;\nvar anInstance = require('../internals/an-instance');\nvar anObject = require('../internals/an-object');\nvar isNullOrUndefined = require('../internals/is-null-or-undefined');\nvar isObject = require('../internals/is-object');\nvar iterate = require('../internals/iterate');\nvar ArrayIterationModule = require('../internals/array-iteration');\nvar hasOwn = require('../internals/has-own-property');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\nvar find = ArrayIterationModule.find;\nvar findIndex = ArrayIterationModule.findIndex;\nvar splice = uncurryThis([].splice);\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (state) {\n return state.frozen || (state.frozen = new UncaughtFrozenStore());\n};\n\nvar UncaughtFrozenStore = function () {\n this.entries = [];\n};\n\nvar findUncaughtFrozen = function (store, key) {\n return find(store.entries, function (it) {\n return it[0] === key;\n });\n};\n\nUncaughtFrozenStore.prototype = {\n get: function (key) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) return entry[1];\n },\n has: function (key) {\n return !!findUncaughtFrozen(this, key);\n },\n set: function (key, value) {\n var entry = findUncaughtFrozen(this, key);\n if (entry) entry[1] = value;\n else this.entries.push([key, value]);\n },\n 'delete': function (key) {\n var index = findIndex(this.entries, function (it) {\n return it[0] === key;\n });\n if (~index) splice(this.entries, index, 1);\n return !!~index;\n }\n};\n\nmodule.exports = {\n getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n var Constructor = wrapper(function (that, iterable) {\n anInstance(that, Prototype);\n setInternalState(that, {\n type: CONSTRUCTOR_NAME,\n id: id++,\n frozen: undefined\n });\n if (!isNullOrUndefined(iterable)) iterate(iterable, that[ADDER], { that: that, AS_ENTRIES: IS_MAP });\n });\n\n var Prototype = Constructor.prototype;\n\n var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n var define = function (that, key, value) {\n var state = getInternalState(that);\n var data = getWeakData(anObject(key), true);\n if (data === true) uncaughtFrozenStore(state).set(key, value);\n else data[state.id] = value;\n return that;\n };\n\n defineBuiltIns(Prototype, {\n // `{ WeakMap, WeakSet }.prototype.delete(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.delete\n // https://tc39.es/ecma262/#sec-weakset.prototype.delete\n 'delete': function (key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state)['delete'](key);\n return data && hasOwn(data, state.id) && delete data[state.id];\n },\n // `{ WeakMap, WeakSet }.prototype.has(key)` methods\n // https://tc39.es/ecma262/#sec-weakmap.prototype.has\n // https://tc39.es/ecma262/#sec-weakset.prototype.has\n has: function has(key) {\n var state = getInternalState(this);\n if (!isObject(key)) return false;\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).has(key);\n return data && hasOwn(data, state.id);\n }\n });\n\n defineBuiltIns(Prototype, IS_MAP ? {\n // `WeakMap.prototype.get(key)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.get\n get: function get(key) {\n var state = getInternalState(this);\n if (isObject(key)) {\n var data = getWeakData(key);\n if (data === true) return uncaughtFrozenStore(state).get(key);\n return data ? data[state.id] : undefined;\n }\n },\n // `WeakMap.prototype.set(key, value)` method\n // https://tc39.es/ecma262/#sec-weakmap.prototype.set\n set: function set(key, value) {\n return define(this, key, value);\n }\n } : {\n // `WeakSet.prototype.add(value)` method\n // https://tc39.es/ecma262/#sec-weakset.prototype.add\n add: function add(value) {\n return define(this, value, true);\n }\n });\n\n return Constructor;\n }\n};\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionWeak = require('../internals/collection-weak');\n\n// `WeakSet` constructor\n// https://tc39.es/ecma262/#sec-weakset-constructor\ncollection('WeakSet', function (init) {\n return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionWeak);\n","'use strict';\n// iterable DOM collections\n// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods\nmodule.exports = {\n CSSRuleList: 0,\n CSSStyleDeclaration: 0,\n CSSValueList: 0,\n ClientRectList: 0,\n DOMRectList: 0,\n DOMStringList: 0,\n DOMTokenList: 1,\n DataTransferItemList: 0,\n FileList: 0,\n HTMLAllCollection: 0,\n HTMLCollection: 0,\n HTMLFormElement: 0,\n HTMLSelectElement: 0,\n MediaList: 0,\n MimeTypeArray: 0,\n NamedNodeMap: 0,\n NodeList: 1,\n PaintRequestList: 0,\n Plugin: 0,\n PluginArray: 0,\n SVGLengthList: 0,\n SVGNumberList: 0,\n SVGPathSegList: 0,\n SVGPointList: 0,\n SVGStringList: 0,\n SVGTransformList: 0,\n SourceBufferList: 0,\n StyleSheetList: 0,\n TextTrackCueList: 0,\n TextTrackList: 0,\n TouchList: 0\n};\n","'use strict';\n// in old WebKit versions, `element.classList` is not an instance of global `DOMTokenList`\nvar documentCreateElement = require('../internals/document-create-element');\n\nvar classList = documentCreateElement('span').classList;\nvar DOMTokenListPrototype = classList && classList.constructor && classList.constructor.prototype;\n\nmodule.exports = DOMTokenListPrototype === Object.prototype ? undefined : DOMTokenListPrototype;\n","'use strict';\nvar global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar DOMTokenListPrototype = require('../internals/dom-token-list-prototype');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nvar handlePrototype = function (CollectionPrototype, COLLECTION_NAME) {\n if (CollectionPrototype) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n } catch (error) {\n CollectionPrototype[ITERATOR] = ArrayValues;\n }\n setToStringTag(CollectionPrototype, COLLECTION_NAME, true);\n if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n // some Chrome versions have non-configurable methods on DOMTokenList\n if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n } catch (error) {\n CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n }\n }\n }\n};\n\nfor (var COLLECTION_NAME in DOMIterables) {\n handlePrototype(global[COLLECTION_NAME] && global[COLLECTION_NAME].prototype, COLLECTION_NAME);\n}\n\nhandlePrototype(DOMTokenListPrototype, 'DOMTokenList');\n","/******************************************************************************\r\nCopyright (c) Microsoft Corporation.\r\n\r\nPermission to use, copy, modify, and/or distribute this software for any\r\npurpose with or without fee is hereby granted.\r\n\r\nTHE SOFTWARE IS PROVIDED \"AS IS\" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH\r\nREGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY\r\nAND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,\r\nINDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM\r\nLOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR\r\nOTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR\r\nPERFORMANCE OF THIS SOFTWARE.\r\n***************************************************************************** */\r\n/* global Reflect, Promise */\r\n\r\nvar extendStatics = function(d, b) {\r\n extendStatics = Object.setPrototypeOf ||\r\n ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||\r\n function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };\r\n return extendStatics(d, b);\r\n};\r\n\r\nexport function __extends(d, b) {\r\n if (typeof b !== \"function\" && b !== null)\r\n throw new TypeError(\"Class extends value \" + String(b) + \" is not a constructor or null\");\r\n extendStatics(d, b);\r\n function __() { this.constructor = d; }\r\n d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());\r\n}\r\n\r\nexport var __assign = function() {\r\n __assign = Object.assign || function __assign(t) {\r\n for (var s, i = 1, n = arguments.length; i < n; i++) {\r\n s = arguments[i];\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];\r\n }\r\n return t;\r\n }\r\n return __assign.apply(this, arguments);\r\n}\r\n\r\nexport function __rest(s, e) {\r\n var t = {};\r\n for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)\r\n t[p] = s[p];\r\n if (s != null && typeof Object.getOwnPropertySymbols === \"function\")\r\n for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {\r\n if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))\r\n t[p[i]] = s[p[i]];\r\n }\r\n return t;\r\n}\r\n\r\nexport function __decorate(decorators, target, key, desc) {\r\n var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;\r\n if (typeof Reflect === \"object\" && typeof Reflect.decorate === \"function\") r = Reflect.decorate(decorators, target, key, desc);\r\n else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;\r\n return c > 3 && r && Object.defineProperty(target, key, r), r;\r\n}\r\n\r\nexport function __param(paramIndex, decorator) {\r\n return function (target, key) { decorator(target, key, paramIndex); }\r\n}\r\n\r\nexport function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {\r\n function accept(f) { if (f !== void 0 && typeof f !== \"function\") throw new TypeError(\"Function expected\"); return f; }\r\n var kind = contextIn.kind, key = kind === \"getter\" ? \"get\" : kind === \"setter\" ? \"set\" : \"value\";\r\n var target = !descriptorIn && ctor ? contextIn[\"static\"] ? ctor : ctor.prototype : null;\r\n var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});\r\n var _, done = false;\r\n for (var i = decorators.length - 1; i >= 0; i--) {\r\n var context = {};\r\n for (var p in contextIn) context[p] = p === \"access\" ? {} : contextIn[p];\r\n for (var p in contextIn.access) context.access[p] = contextIn.access[p];\r\n context.addInitializer = function (f) { if (done) throw new TypeError(\"Cannot add initializers after decoration has completed\"); extraInitializers.push(accept(f || null)); };\r\n var result = (0, decorators[i])(kind === \"accessor\" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);\r\n if (kind === \"accessor\") {\r\n if (result === void 0) continue;\r\n if (result === null || typeof result !== \"object\") throw new TypeError(\"Object expected\");\r\n if (_ = accept(result.get)) descriptor.get = _;\r\n if (_ = accept(result.set)) descriptor.set = _;\r\n if (_ = accept(result.init)) initializers.unshift(_);\r\n }\r\n else if (_ = accept(result)) {\r\n if (kind === \"field\") initializers.unshift(_);\r\n else descriptor[key] = _;\r\n }\r\n }\r\n if (target) Object.defineProperty(target, contextIn.name, descriptor);\r\n done = true;\r\n};\r\n\r\nexport function __runInitializers(thisArg, initializers, value) {\r\n var useValue = arguments.length > 2;\r\n for (var i = 0; i < initializers.length; i++) {\r\n value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);\r\n }\r\n return useValue ? value : void 0;\r\n};\r\n\r\nexport function __propKey(x) {\r\n return typeof x === \"symbol\" ? x : \"\".concat(x);\r\n};\r\n\r\nexport function __setFunctionName(f, name, prefix) {\r\n if (typeof name === \"symbol\") name = name.description ? \"[\".concat(name.description, \"]\") : \"\";\r\n return Object.defineProperty(f, \"name\", { configurable: true, value: prefix ? \"\".concat(prefix, \" \", name) : name });\r\n};\r\n\r\nexport function __metadata(metadataKey, metadataValue) {\r\n if (typeof Reflect === \"object\" && typeof Reflect.metadata === \"function\") return Reflect.metadata(metadataKey, metadataValue);\r\n}\r\n\r\nexport function __awaiter(thisArg, _arguments, P, generator) {\r\n function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }\r\n return new (P || (P = Promise))(function (resolve, reject) {\r\n function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }\r\n function rejected(value) { try { step(generator[\"throw\"](value)); } catch (e) { reject(e); } }\r\n function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }\r\n step((generator = generator.apply(thisArg, _arguments || [])).next());\r\n });\r\n}\r\n\r\nexport function __generator(thisArg, body) {\r\n var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;\r\n return g = { next: verb(0), \"throw\": verb(1), \"return\": verb(2) }, typeof Symbol === \"function\" && (g[Symbol.iterator] = function() { return this; }), g;\r\n function verb(n) { return function (v) { return step([n, v]); }; }\r\n function step(op) {\r\n if (f) throw new TypeError(\"Generator is already executing.\");\r\n while (g && (g = 0, op[0] && (_ = 0)), _) try {\r\n 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;\r\n if (y = 0, t) op = [op[0] & 2, t.value];\r\n switch (op[0]) {\r\n case 0: case 1: t = op; break;\r\n case 4: _.label++; return { value: op[1], done: false };\r\n case 5: _.label++; y = op[1]; op = [0]; continue;\r\n case 7: op = _.ops.pop(); _.trys.pop(); continue;\r\n default:\r\n if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }\r\n if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }\r\n if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }\r\n if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }\r\n if (t[2]) _.ops.pop();\r\n _.trys.pop(); continue;\r\n }\r\n op = body.call(thisArg, _);\r\n } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }\r\n if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };\r\n }\r\n}\r\n\r\nexport var __createBinding = Object.create ? (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n var desc = Object.getOwnPropertyDescriptor(m, k);\r\n if (!desc || (\"get\" in desc ? !m.__esModule : desc.writable || desc.configurable)) {\r\n desc = { enumerable: true, get: function() { return m[k]; } };\r\n }\r\n Object.defineProperty(o, k2, desc);\r\n}) : (function(o, m, k, k2) {\r\n if (k2 === undefined) k2 = k;\r\n o[k2] = m[k];\r\n});\r\n\r\nexport function __exportStar(m, o) {\r\n for (var p in m) if (p !== \"default\" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);\r\n}\r\n\r\nexport function __values(o) {\r\n var s = typeof Symbol === \"function\" && Symbol.iterator, m = s && o[s], i = 0;\r\n if (m) return m.call(o);\r\n if (o && typeof o.length === \"number\") return {\r\n next: function () {\r\n if (o && i >= o.length) o = void 0;\r\n return { value: o && o[i++], done: !o };\r\n }\r\n };\r\n throw new TypeError(s ? \"Object is not iterable.\" : \"Symbol.iterator is not defined.\");\r\n}\r\n\r\nexport function __read(o, n) {\r\n var m = typeof Symbol === \"function\" && o[Symbol.iterator];\r\n if (!m) return o;\r\n var i = m.call(o), r, ar = [], e;\r\n try {\r\n while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);\r\n }\r\n catch (error) { e = { error: error }; }\r\n finally {\r\n try {\r\n if (r && !r.done && (m = i[\"return\"])) m.call(i);\r\n }\r\n finally { if (e) throw e.error; }\r\n }\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spread() {\r\n for (var ar = [], i = 0; i < arguments.length; i++)\r\n ar = ar.concat(__read(arguments[i]));\r\n return ar;\r\n}\r\n\r\n/** @deprecated */\r\nexport function __spreadArrays() {\r\n for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;\r\n for (var r = Array(s), k = 0, i = 0; i < il; i++)\r\n for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)\r\n r[k] = a[j];\r\n return r;\r\n}\r\n\r\nexport function __spreadArray(to, from, pack) {\r\n if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {\r\n if (ar || !(i in from)) {\r\n if (!ar) ar = Array.prototype.slice.call(from, 0, i);\r\n ar[i] = from[i];\r\n }\r\n }\r\n return to.concat(ar || Array.prototype.slice.call(from));\r\n}\r\n\r\nexport function __await(v) {\r\n return this instanceof __await ? (this.v = v, this) : new __await(v);\r\n}\r\n\r\nexport function __asyncGenerator(thisArg, _arguments, generator) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var g = generator.apply(thisArg, _arguments || []), i, q = [];\r\n return i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i;\r\n function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }\r\n function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }\r\n function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }\r\n function fulfill(value) { resume(\"next\", value); }\r\n function reject(value) { resume(\"throw\", value); }\r\n function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }\r\n}\r\n\r\nexport function __asyncDelegator(o) {\r\n var i, p;\r\n return i = {}, verb(\"next\"), verb(\"throw\", function (e) { throw e; }), verb(\"return\"), i[Symbol.iterator] = function () { return this; }, i;\r\n function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }\r\n}\r\n\r\nexport function __asyncValues(o) {\r\n if (!Symbol.asyncIterator) throw new TypeError(\"Symbol.asyncIterator is not defined.\");\r\n var m = o[Symbol.asyncIterator], i;\r\n return m ? m.call(o) : (o = typeof __values === \"function\" ? __values(o) : o[Symbol.iterator](), i = {}, verb(\"next\"), verb(\"throw\"), verb(\"return\"), i[Symbol.asyncIterator] = function () { return this; }, i);\r\n function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }\r\n function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }\r\n}\r\n\r\nexport function __makeTemplateObject(cooked, raw) {\r\n if (Object.defineProperty) { Object.defineProperty(cooked, \"raw\", { value: raw }); } else { cooked.raw = raw; }\r\n return cooked;\r\n};\r\n\r\nvar __setModuleDefault = Object.create ? (function(o, v) {\r\n Object.defineProperty(o, \"default\", { enumerable: true, value: v });\r\n}) : function(o, v) {\r\n o[\"default\"] = v;\r\n};\r\n\r\nexport function __importStar(mod) {\r\n if (mod && mod.__esModule) return mod;\r\n var result = {};\r\n if (mod != null) for (var k in mod) if (k !== \"default\" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);\r\n __setModuleDefault(result, mod);\r\n return result;\r\n}\r\n\r\nexport function __importDefault(mod) {\r\n return (mod && mod.__esModule) ? mod : { default: mod };\r\n}\r\n\r\nexport function __classPrivateFieldGet(receiver, state, kind, f) {\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a getter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot read private member from an object whose class did not declare it\");\r\n return kind === \"m\" ? f : kind === \"a\" ? f.call(receiver) : f ? f.value : state.get(receiver);\r\n}\r\n\r\nexport function __classPrivateFieldSet(receiver, state, value, kind, f) {\r\n if (kind === \"m\") throw new TypeError(\"Private method is not writable\");\r\n if (kind === \"a\" && !f) throw new TypeError(\"Private accessor was defined without a setter\");\r\n if (typeof state === \"function\" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError(\"Cannot write private member to an object whose class did not declare it\");\r\n return (kind === \"a\" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;\r\n}\r\n\r\nexport function __classPrivateFieldIn(state, receiver) {\r\n if (receiver === null || (typeof receiver !== \"object\" && typeof receiver !== \"function\")) throw new TypeError(\"Cannot use 'in' operator on non-object\");\r\n return typeof state === \"function\" ? receiver === state : state.has(receiver);\r\n}\r\n\r\nexport default {\r\n __extends,\r\n __assign,\r\n __rest,\r\n __decorate,\r\n __param,\r\n __metadata,\r\n __awaiter,\r\n __generator,\r\n __createBinding,\r\n __exportStar,\r\n __values,\r\n __read,\r\n __spread,\r\n __spreadArrays,\r\n __spreadArray,\r\n __await,\r\n __asyncGenerator,\r\n __asyncDelegator,\r\n __asyncValues,\r\n __makeTemplateObject,\r\n __importStar,\r\n __importDefault,\r\n __classPrivateFieldGet,\r\n __classPrivateFieldSet,\r\n __classPrivateFieldIn,\r\n};\r\n","import { createPopper } from '@popperjs/core';\n\nimport type dayjs from 'dayjs';\nimport type { VirtualElement, StrictModifiers } from '@popperjs/core';\nimport type CalHeatmap from '../CalHeatmap';\nimport type { IPlugin, PluginOptions, Timestamp } from '../index';\n\nconst DEFAULT_SELECTOR = '#ch-tooltip';\n\ninterface PopperOptions {\n placement: any;\n modifiers: any[];\n strategy: any;\n onFirstUpdate?: any;\n}\n\ninterface TooltipOptions extends PluginOptions, PopperOptions {\n enabled: boolean;\n text: (timestamp: Timestamp, value: number, dayjsDate: dayjs.Dayjs) => string;\n}\n\nconst defaultOptions: Partial = {\n enabled: true,\n\n // Expecting a function, which will return the tooltip content\n text: (_timestamp, value, dayjsDate): string =>\n // eslint-disable-next-line implicit-arrow-linebreak\n `${value} - ${dayjsDate.format('LLLL')}`,\n};\n\nconst DEFAULT_POPPER_OPTIONS = {\n placement: 'top',\n modifiers: [\n {\n name: 'offset',\n options: {\n offset: [0, 8],\n },\n },\n ],\n};\n\nconst virtualElement: VirtualElement = {\n getBoundingClientRect(x = 0, y = 0): DOMRect {\n return {\n width: 0,\n height: 0,\n top: y,\n right: x,\n bottom: y,\n left: x,\n x,\n y,\n toJSON: () => {},\n };\n },\n};\n\nexport default class Tooltip implements IPlugin {\n name = 'Tooltip';\n\n calendar: CalHeatmap;\n\n root: HTMLElement | null;\n\n popperInstance: any;\n\n popperOptions: any;\n\n options: Partial;\n\n listenerAttached: boolean;\n\n constructor(calendar: CalHeatmap) {\n this.calendar = calendar;\n this.root = null;\n this.popperInstance = null;\n this.options = defaultOptions;\n this.listenerAttached = false;\n }\n\n setup(pluginOptions?: Partial): void {\n this.options = { ...defaultOptions, ...pluginOptions };\n const event = this.calendar.eventEmitter;\n\n if (!this.options.enabled) {\n if (this.listenerAttached) {\n event.off('mouseover', this.mouseOverCallback, this);\n event.off('mouseout', this.mouseOutCallback, this);\n\n this.listenerAttached = false;\n }\n\n this.destroy();\n return;\n }\n\n this.popperOptions = { ...DEFAULT_POPPER_OPTIONS, ...this.options };\n\n this.root = document.getElementById(DEFAULT_SELECTOR.slice(1));\n\n if (!this.root) {\n const tooltipElem = document.createElement('div');\n tooltipElem.setAttribute('id', DEFAULT_SELECTOR.slice(1));\n tooltipElem.setAttribute('role', 'tooltip');\n tooltipElem.innerHTML =\n `
` +\n ``;\n\n this.root = document.body.appendChild(tooltipElem);\n }\n\n this.root.setAttribute('data-theme', this.calendar.options.options.theme);\n\n this.popperInstance = createPopper(\n virtualElement,\n this.root,\n this.popperOptions,\n );\n\n if (!this.listenerAttached) {\n event.on('mouseover', this.mouseOverCallback, this);\n event.on('mouseout', this.mouseOutCallback, this);\n this.listenerAttached = true;\n }\n }\n\n mouseOverCallback(e: PointerEvent, timestamp: Timestamp, value: number) {\n this.#show(e.target, timestamp, value);\n }\n\n mouseOutCallback() {\n this.#hide();\n }\n\n // eslint-disable-next-line class-methods-use-this\n paint(): Promise {\n return Promise.resolve();\n }\n\n destroy(): Promise {\n if (this.root) {\n this.root.remove();\n }\n\n return Promise.resolve();\n }\n\n #show(e: any, timestamp: Timestamp, value: number): void {\n const formatter = this.options.text;\n const title = formatter ?\n formatter(timestamp, value, this.calendar.dateHelper.date(timestamp)) :\n null;\n\n if (!title) {\n return;\n }\n\n virtualElement.getBoundingClientRect = () => e.getBoundingClientRect();\n document.getElementById(`${DEFAULT_SELECTOR.slice(1)}-body`)!.innerHTML =\n title;\n\n this.popperInstance.setOptions(() => ({\n ...this.popperOptions,\n modifiers: [\n ...this.popperOptions.modifiers,\n { name: 'eventListeners', enabled: true },\n ],\n }));\n\n this.popperInstance.update();\n\n this.root!.setAttribute('data-show', '1');\n }\n\n #hide(): void {\n this.root!.removeAttribute('data-show');\n\n this.popperInstance.setOptions(() => ({\n ...this.popperOptions,\n modifiers: [\n ...this.popperOptions.modifiers,\n { name: 'eventListeners', enabled: false },\n ],\n }));\n }\n}\n"],"names":["commonjsGlobal","globalThis","window","global","self","check","it","Math","this","Function","fails","exec","error","descriptors","require$$0","Object","defineProperty","get","functionBindNative","test","bind","hasOwnProperty","NATIVE_BIND","call","prototype","functionCall","apply","arguments","$propertyIsEnumerable","propertyIsEnumerable","getOwnPropertyDescriptor","NASHORN_BUG","objectPropertyIsEnumerable","f","V","descriptor","enumerable","match","version","createPropertyDescriptor","bitmap","value","configurable","writable","FunctionPrototype","uncurryThisWithBind","functionUncurryThis","fn","uncurryThis","toString","stringSlice","slice","classofRaw","require$$1","classof","require$$2","$Object","split","indexedObject","isNullOrUndefined","$TypeError","TypeError","requireObjectCoercible","IndexedObject","toIndexedObject","documentAll","document","all","documentAll_1","IS_HTMLDDA","undefined","isCallable","argument","isObject","getBuiltIn","namespace","method","length","objectIsPrototypeOf","isPrototypeOf","engineUserAgent","navigator","String","userAgent","process","Deno","versions","v8","engineV8Version","V8_VERSION","$String","symbolConstructorDetection","getOwnPropertySymbols","symbol","Symbol","sham","useSymbolAsUid","iterator","isSymbol","require$$3","$Symbol","tryToString","aCallable","getMethod","P","func","shared$3","exports","defineGlobalProperty","key","SHARED","sharedStore","store","sharedModule","push","mode","copyright","license","source","toObject","hasOwnProperty_1","hasOwn","id","postfix","random","uid","shared","NATIVE_SYMBOL","require$$4","USE_SYMBOL_AS_UID","require$$5","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","wellKnownSymbol","name","ordinaryToPrimitive","input","pref","val","valueOf","TO_PRIMITIVE","toPrimitive","result","exoticToPrim","toPropertyKey","EXISTS","createElement","documentCreateElement","ie8DomDefine","a","DESCRIPTORS","propertyIsEnumerableModule","require$$6","IE8_DOM_DEFINE","require$$7","$getOwnPropertyDescriptor","objectGetOwnPropertyDescriptor","O","objectDefineProperty","v8PrototypeDefineBug","anObject","V8_PROTOTYPE_DEFINE_BUG","$defineProperty","ENUMERABLE","CONFIGURABLE","WRITABLE","Attributes","current","definePropertyModule","createNonEnumerableProperty","object","makeBuiltIn$3","getDescriptor","functionName","PROPER","functionToString","inspectSource","set","has","WeakMap","weakMapBasicDetection","keys","sharedKey","hiddenKeys","NATIVE_WEAK_MAP","OBJECT_ALREADY_INITIALIZED","state","metadata","facade","STATE","internalState","enforce","getterFor","TYPE","type","CONFIGURABLE_FUNCTION_NAME","enforceInternalState","getInternalState","replace","join","CONFIGURABLE_LENGTH","TEMPLATE","makeBuiltIn","makeBuiltInModule","options","getter","setter","arity","constructor","defineBuiltIn","simple","unsafe","nonConfigurable","nonWritable","ceil","floor","trunc","x","n","toIntegerOrInfinity","number","max","min","toAbsoluteIndex","index","integer","toLength","lengthOfArrayLike","obj","createMethod","IS_INCLUDES","$this","el","fromIndex","arrayIncludes","includes","indexOf","objectKeysInternal","names","i","enumBugKeys","internalObjectKeys","concat","objectGetOwnPropertyNames","getOwnPropertyNames","objectGetOwnPropertySymbols","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","ownKeys","getOwnPropertyDescriptorModule","replacement","isForced","feature","detection","data","normalize","POLYFILL","NATIVE","string","toLowerCase","isForced_1","copyConstructorProperties","target","exceptions","_export","targetProperty","sourceProperty","TARGET","GLOBAL","STATIC","stat","dontCallGetSet","forced","isArray","Array","createProperty","propertyKey","toStringTagSupport","TO_STRING_TAG_SUPPORT","TO_STRING_TAG","CORRECT_ARGUMENTS","tag","tryGet","callee","noop","empty","construct","constructorRegExp","INCORRECT_TO_STRING","isConstructorModern","isConstructorLegacy","isConstructor","called","SPECIES","$Array","arraySpeciesConstructor","originalArray","C","arraySpeciesCreate","$","doesNotExceedSafeInteger","require$$8","arrayMethodHasSpeciesSupport","METHOD_NAME","array","foo","Boolean","require$$11","IS_CONCAT_SPREADABLE","require$$10","IS_CONCAT_SPREADABLE_SUPPORT","isConcatSpreadable","spreadable","proto","arg","k","len","E","A","defineBuiltInAccessor","FUNCTION_NAME_EXISTS","nameRE","regExpExec","objectKeys","$assign","assign","objectAssign","b","B","alphabet","forEach","chr","T","argumentsLength","S","j","$location","defer","channel","port","engineIsNode","uncurryThisAccessor","aPossiblePrototype","objectSetPrototypeOf","setPrototypeOf","CORRECT_SETTER","__proto__","setToStringTag","TAG","anInstance","Prototype","aConstructor","functionApply","Reflect","functionBindContext","that","html","arraySlice","engineIsIos","validateArgumentsLength","passed","required","IS_IOS","IS_NODE","setImmediate","clear","clearImmediate","Dispatch","MessageChannel","counter","queue","ONREADYSTATECHANGE","location","run","runner","eventListener","event","globalPostMessageDefer","postMessage","protocol","host","handler","args","nextTick","now","port2","port1","onmessage","addEventListener","importScripts","appendChild","removeChild","setTimeout","task","Queue","head","tail","add","item","entry","next","notify","toggle","node","promise","then","engineIsIosPebble","Pebble","engineIsWebosWebkit","macrotask","IS_IOS_PEBBLE","IS_WEBOS_WEBKIT","MutationObserver","WebKitMutationObserver","Promise","queueMicrotaskDescriptor","microtask","flush","parent","domain","exit","enter","resolve","createTextNode","observe","characterData","microtask_1","perform","promiseNativeConstructor","engineIsDeno","engineIsBrowser","NativePromiseConstructor","IS_BROWSER","IS_DENO","require$$9","SUBCLASSING","NATIVE_PROMISE_REJECTION_EVENT","PromiseRejectionEvent","FORCED_PROMISE_CONSTRUCTOR","PROMISE_CONSTRUCTOR_SOURCE","GLOBAL_CORE_JS_PROMISE","FakePromise","promiseConstructorDetection","CONSTRUCTOR","REJECTION_EVENT","newPromiseCapability$2","PromiseCapability","reject","$$resolve","$$reject","newPromiseCapability","Internal","OwnPromiseCapability","nativeThen","setSpecies","CONSTRUCTOR_NAME","Constructor","require$$12","speciesConstructor","defaultConstructor","require$$14","require$$15","hostReportErrors","console","require$$17","require$$18","InternalStateModule","require$$19","require$$20","newPromiseCapabilityModule","require$$22","PROMISE","require$$21","NATIVE_PROMISE_SUBCLASSING","getInternalPromiseState","setInternalState","NativePromisePrototype","PromiseConstructor","PromisePrototype","newGenericPromiseCapability","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","isThenable","callReaction","reaction","exited","ok","fail","rejection","onHandleUnhandled","isReject","notified","reactions","onUnhandled","reason","initEvent","isUnhandled","emit","unwrap","internalReject","done","internalResolve","wrapper","executor","onFulfilled","onRejected","PromiseWrapper","wrap","iterators","Iterators","ITERATOR","ArrayPrototype","getIteratorMethod","isArrayIteratorMethod","getIterator","usingIterator","iteratorMethod","iteratorClose","kind","innerResult","innerError","Result","stopped","ResultPrototype","iterate","iterable","unboundFunction","iterFn","step","AS_ENTRIES","IS_RECORD","IS_ITERATOR","INTERRUPTED","stop","condition","callFn","SAFE_CLOSING","iteratorWithReturn","return","from","checkCorrectnessOfIteration","SKIP_CLOSING","ITERATION_SUPPORT","promiseStaticsIncorrectIteration","capability","$promiseResolve","values","remaining","alreadyCalled","real","catch","race","r","promiseResolve","promiseCapability","objectDefineProperties","defineProperties","Properties","props","activeXDocument","definePropertiesModule","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","LT","NullProtoObjectViaActiveX","write","close","temp","parentWindow","NullProtoObject","ActiveXObject","iframeDocument","iframe","JS","style","display","src","contentWindow","open","F","objectCreate","create","UNSCOPABLES","IteratorPrototype","PrototypeOfArrayIteratorPrototype","arrayIterator","correctPrototypeGetter","getPrototypeOf","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","objectGetPrototypeOf","BUGGY_SAFARI_ITERATORS","NEW_ITERATOR_PROTOTYPE","iteratorsCore","returnThis","createIteratorConstructor","IteratorConstructor","NAME","ENUMERABLE_NEXT","PROPER_FUNCTION_NAME","require$$13","KEYS","VALUES","ENTRIES","iteratorDefine","Iterable","DEFAULT","IS_SET","FORCED","CurrentIteratorPrototype","methods","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","entries","createIterResultObject","addToUnscopables","defineIterator","ARRAY_ITERATOR","es_array_iterator","iterated","Arguments","charAt","charCodeAt","CONVERT_TO_STRING","pos","first","second","position","size","codeAt","STRING_ITERATOR","point","internalMetadata","objectGetOwnPropertyNamesExternal","$getOwnPropertyNames","start","end","fin","windowNames","getWindowNames","arrayBufferNonExtensible","ArrayBuffer","buffer","isExtensible","ARRAY_BUFFER_NON_EXTENSIBLE","$isExtensible","objectIsExtensible","freezing","preventExtensions","getOwnPropertyNamesExternalModule","FREEZING","REQUIRED","METADATA","setMetadata","objectID","weakData","meta","internalMetadataModule","enable","splice","fastKey","getWeakData","onFreeze","InternalMetadataModule","inheritIfRequired","dummy","Wrapper","NewTarget","NewTargetPrototype","IS_MAP","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","IS_FILTER_REJECT","NO_HOLES","callbackfn","specificCreate","boundFunction","arrayIteration","map","filter","some","every","find","findIndex","filterReject","defineBuiltIns","internalStateGetterFor","uncaughtFrozenStore","frozen","UncaughtFrozenStore","findUncaughtFrozen","delete","collectionWeak","getConstructor","ADDER","define","common","IS_WEAK","NativeConstructor","NativePrototype","exported","fixMethod","uncurriedNativeMethod","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","setStrong","collection","init","classList","DOMTokenListPrototype","domTokenListPrototype","DOMIterables","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DOMTokenList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","ArrayIteratorMethods","ArrayValues","handlePrototype","CollectionPrototype","COLLECTION_NAME","__classPrivateFieldGet","receiver","DEFAULT_SELECTOR","defaultOptions","enabled","text","_timestamp","dayjsDate","format","DEFAULT_POPPER_OPTIONS","placement","modifiers","offset","virtualElement","getBoundingClientRect","y","width","height","top","right","bottom","left","toJSON","Tooltip","calendar","_classCallCheck","root","popperInstance","listenerAttached","pluginOptions","eventEmitter","off","mouseOverCallback","mouseOutCallback","destroy","popperOptions","getElementById","tooltipElem","setAttribute","innerHTML","body","theme","createPopper","on","e","timestamp","_Tooltip_instances","_Tooltip_show","_Tooltip_hide","remove","_this","formatter","title","dateHelper","date","setOptions","_toConsumableArray","update","_this2","removeAttribute"],"mappings":"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","x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153]} \ No newline at end of file diff --git a/src/agenda_culturel/static/cal-heatmap/plugins/cal-heatmap.css b/src/agenda_culturel/static/cal-heatmap/plugins/cal-heatmap.css new file mode 100644 index 0000000..9bafe15 --- /dev/null +++ b/src/agenda_culturel/static/cal-heatmap/plugins/cal-heatmap.css @@ -0,0 +1 @@ +.ch-container{display:block}.ch-container,.ch-domain,.ch-domain-container,.ch-domain-container-animation-wrapper{overflow:visible}.ch-domain-container.in-transition .ch-domain-container-animation-wrapper{overflow:hidden}.ch-domain-bg{fill:transparent}.ch-domain-text{fill:currentColor;font-size:10px}.ch-subdomain{overflow:visible}.ch-subdomain-bg{fill:#ededed}.ch-subdomain-bg.highlight{stroke:#444;stroke-width:1px}.ch-subdomain-bg:hover{stroke:#000;stroke-width:1px}.ch-subdomain-text{font-size:8px;pointer-events:none}[data-theme=dark] .ch-subdomain-bg{fill:#2d333b}[data-theme=dark] .ch-subdomain-bg.highlight{stroke:#768390}[data-theme=dark] .ch-subdomain-bg:hover{stroke:#636e7b}#ch-plugin-legend>svg{background:transparent;color:currentColor}#ch-tooltip{background:#222;border-radius:2px;box-shadow:2px 2px 2px rgba(0,0,0,.2);box-sizing:border-box;color:#bbb;display:none;font-size:12px;line-height:1.4;padding:5px 10px;text-align:center}#ch-tooltip[data-show]{display:block}#ch-tooltip-arrow,#ch-tooltip-arrow:before{background:inherit;height:8px;position:absolute;width:8px}#ch-tooltip-arrow{visibility:hidden}#ch-tooltip-arrow:before{content:"";transform:rotate(45deg);visibility:visible}#ch-tooltip[data-popper-placement^=top]>#ch-tooltip-arrow{bottom:-4px;margin-left:-4px}#ch-tooltip[data-popper-placement^=bottom]>#ch-tooltip-arrow{margin-left:-4px;top:-4px}#ch-tooltip[data-popper-placement^=left]>#ch-tooltip-arrow{right:-4px}#ch-tooltip[data-popper-placement^=right]>#ch-tooltip-arrow{left:-4px}#ch-tooltip[data-theme=dark]{background:#636e7b;color:#cdd9e5} \ No newline at end of file diff --git a/src/agenda_culturel/static/js/d3.v7.min.js b/src/agenda_culturel/static/js/d3.v7.min.js new file mode 100644 index 0000000..33bb880 --- /dev/null +++ b/src/agenda_culturel/static/js/d3.v7.min.js @@ -0,0 +1,2 @@ +// https://d3js.org v7.9.0 Copyright 2010-2023 Mike Bostock +!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((t="undefined"!=typeof globalThis?globalThis:t||self).d3=t.d3||{})}(this,(function(t){"use strict";function n(t,n){return null==t||null==n?NaN:tn?1:t>=n?0:NaN}function e(t,n){return null==t||null==n?NaN:nt?1:n>=t?0:NaN}function r(t){let r,o,a;function u(t,n,e=0,i=t.length){if(e>>1;o(t[r],n)<0?e=r+1:i=r}while(en(t(e),r),a=(n,e)=>t(n)-e):(r=t===n||t===e?t:i,o=t,a=t),{left:u,center:function(t,n,e=0,r=t.length){const i=u(t,n,e,r-1);return i>e&&a(t[i-1],n)>-a(t[i],n)?i-1:i},right:function(t,n,e=0,i=t.length){if(e>>1;o(t[r],n)<=0?e=r+1:i=r}while(e{n(t,e,(r<<=2)+0,(i<<=2)+0,o<<=2),n(t,e,r+1,i+1,o),n(t,e,r+2,i+2,o),n(t,e,r+3,i+3,o)}}));function d(t){return function(n,e,r=e){if(!((e=+e)>=0))throw new RangeError("invalid rx");if(!((r=+r)>=0))throw new RangeError("invalid ry");let{data:i,width:o,height:a}=n;if(!((o=Math.floor(o))>=0))throw new RangeError("invalid width");if(!((a=Math.floor(void 0!==a?a:i.length/o))>=0))throw new RangeError("invalid height");if(!o||!a||!e&&!r)return n;const u=e&&t(e),c=r&&t(r),f=i.slice();return u&&c?(p(u,f,i,o,a),p(u,i,f,o,a),p(u,f,i,o,a),g(c,i,f,o,a),g(c,f,i,o,a),g(c,i,f,o,a)):u?(p(u,i,f,o,a),p(u,f,i,o,a),p(u,i,f,o,a)):c&&(g(c,i,f,o,a),g(c,f,i,o,a),g(c,i,f,o,a)),n}}function p(t,n,e,r,i){for(let o=0,a=r*i;o{if(!((o-=a)>=i))return;let u=t*r[i];const c=a*t;for(let t=i,n=i+c;t{if(!((a-=u)>=o))return;let c=n*i[o];const f=u*n,s=f+u;for(let t=o,n=o+f;t=n&&++e;else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&(i=+i)>=i&&++e}return e}function _(t){return 0|t.length}function b(t){return!(t>0)}function m(t){return"object"!=typeof t||"length"in t?t:Array.from(t)}function x(t,n){let e,r=0,i=0,o=0;if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&(e=n-i,i+=e/++r,o+=e*(n-i));else{let a=-1;for(let u of t)null!=(u=n(u,++a,t))&&(u=+u)>=u&&(e=u-i,i+=e/++r,o+=e*(u-i))}if(r>1)return o/(r-1)}function w(t,n){const e=x(t,n);return e?Math.sqrt(e):e}function M(t,n){let e,r;if(void 0===n)for(const n of t)null!=n&&(void 0===e?n>=n&&(e=r=n):(e>n&&(e=n),r=o&&(e=r=o):(e>o&&(e=o),r0){for(o=t[--i];i>0&&(n=o,e=t[--i],o=n+e,r=e-(o-n),!r););i>0&&(r<0&&t[i-1]<0||r>0&&t[i-1]>0)&&(e=2*r,n=o+e,e==n-o&&(o=n))}return o}}class InternMap extends Map{constructor(t,n=N){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:n}}),null!=t)for(const[n,e]of t)this.set(n,e)}get(t){return super.get(A(this,t))}has(t){return super.has(A(this,t))}set(t,n){return super.set(S(this,t),n)}delete(t){return super.delete(E(this,t))}}class InternSet extends Set{constructor(t,n=N){if(super(),Object.defineProperties(this,{_intern:{value:new Map},_key:{value:n}}),null!=t)for(const n of t)this.add(n)}has(t){return super.has(A(this,t))}add(t){return super.add(S(this,t))}delete(t){return super.delete(E(this,t))}}function A({_intern:t,_key:n},e){const r=n(e);return t.has(r)?t.get(r):e}function S({_intern:t,_key:n},e){const r=n(e);return t.has(r)?t.get(r):(t.set(r,e),e)}function E({_intern:t,_key:n},e){const r=n(e);return t.has(r)&&(e=t.get(r),t.delete(r)),e}function N(t){return null!==t&&"object"==typeof t?t.valueOf():t}function k(t){return t}function C(t,...n){return F(t,k,k,n)}function P(t,...n){return F(t,Array.from,k,n)}function z(t,n){for(let e=1,r=n.length;et.pop().map((([n,e])=>[...t,n,e]))));return t}function $(t,n,...e){return F(t,k,n,e)}function D(t,n,...e){return F(t,Array.from,n,e)}function R(t){if(1!==t.length)throw new Error("duplicate key");return t[0]}function F(t,n,e,r){return function t(i,o){if(o>=r.length)return e(i);const a=new InternMap,u=r[o++];let c=-1;for(const t of i){const n=u(t,++c,i),e=a.get(n);e?e.push(t):a.set(n,[t])}for(const[n,e]of a)a.set(n,t(e,o));return n(a)}(t,0)}function q(t,n){return Array.from(n,(n=>t[n]))}function U(t,...n){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");t=Array.from(t);let[e]=n;if(e&&2!==e.length||n.length>1){const r=Uint32Array.from(t,((t,n)=>n));return n.length>1?(n=n.map((n=>t.map(n))),r.sort(((t,e)=>{for(const r of n){const n=O(r[t],r[e]);if(n)return n}}))):(e=t.map(e),r.sort(((t,n)=>O(e[t],e[n])))),q(t,r)}return t.sort(I(e))}function I(t=n){if(t===n)return O;if("function"!=typeof t)throw new TypeError("compare is not a function");return(n,e)=>{const r=t(n,e);return r||0===r?r:(0===t(e,e))-(0===t(n,n))}}function O(t,n){return(null==t||!(t>=t))-(null==n||!(n>=n))||(tn?1:0)}var B=Array.prototype.slice;function Y(t){return()=>t}const L=Math.sqrt(50),j=Math.sqrt(10),H=Math.sqrt(2);function X(t,n,e){const r=(n-t)/Math.max(0,e),i=Math.floor(Math.log10(r)),o=r/Math.pow(10,i),a=o>=L?10:o>=j?5:o>=H?2:1;let u,c,f;return i<0?(f=Math.pow(10,-i)/a,u=Math.round(t*f),c=Math.round(n*f),u/fn&&--c,f=-f):(f=Math.pow(10,i)*a,u=Math.round(t/f),c=Math.round(n/f),u*fn&&--c),c0))return[];if((t=+t)===(n=+n))return[t];const r=n=i))return[];const u=o-i+1,c=new Array(u);if(r)if(a<0)for(let t=0;t0?(t=Math.floor(t/i)*i,n=Math.ceil(n/i)*i):i<0&&(t=Math.ceil(t*i)/i,n=Math.floor(n*i)/i),r=i}}function K(t){return Math.max(1,Math.ceil(Math.log(v(t))/Math.LN2)+1)}function Q(){var t=k,n=M,e=K;function r(r){Array.isArray(r)||(r=Array.from(r));var i,o,a,u=r.length,c=new Array(u);for(i=0;i=h)if(t>=h&&n===M){const t=V(l,h,e);isFinite(t)&&(t>0?h=(Math.floor(h/t)+1)*t:t<0&&(h=(Math.ceil(h*-t)+1)/-t))}else d.pop()}for(var p=d.length,g=0,y=p;d[g]<=l;)++g;for(;d[y-1]>h;)--y;(g||y0?d[i-1]:l,v.x1=i0)for(i=0;i=n)&&(e=n);else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&(e=i)&&(e=i)}return e}function tt(t,n){let e,r=-1,i=-1;if(void 0===n)for(const n of t)++i,null!=n&&(e=n)&&(e=n,r=i);else for(let o of t)null!=(o=n(o,++i,t))&&(e=o)&&(e=o,r=i);return r}function nt(t,n){let e;if(void 0===n)for(const n of t)null!=n&&(e>n||void 0===e&&n>=n)&&(e=n);else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&(e>i||void 0===e&&i>=i)&&(e=i)}return e}function et(t,n){let e,r=-1,i=-1;if(void 0===n)for(const n of t)++i,null!=n&&(e>n||void 0===e&&n>=n)&&(e=n,r=i);else for(let o of t)null!=(o=n(o,++i,t))&&(e>o||void 0===e&&o>=o)&&(e=o,r=i);return r}function rt(t,n,e=0,r=1/0,i){if(n=Math.floor(n),e=Math.floor(Math.max(0,e)),r=Math.floor(Math.min(t.length-1,r)),!(e<=n&&n<=r))return t;for(i=void 0===i?O:I(i);r>e;){if(r-e>600){const o=r-e+1,a=n-e+1,u=Math.log(o),c=.5*Math.exp(2*u/3),f=.5*Math.sqrt(u*c*(o-c)/o)*(a-o/2<0?-1:1);rt(t,n,Math.max(e,Math.floor(n-a*c/o+f)),Math.min(r,Math.floor(n+(o-a)*c/o+f)),i)}const o=t[n];let a=e,u=r;for(it(t,e,n),i(t[r],o)>0&&it(t,e,r);a0;)--u}0===i(t[e],o)?it(t,e,u):(++u,it(t,u,r)),u<=n&&(e=u+1),n<=u&&(r=u-1)}return t}function it(t,n,e){const r=t[n];t[n]=t[e],t[e]=r}function ot(t,e=n){let r,i=!1;if(1===e.length){let o;for(const a of t){const t=e(a);(i?n(t,o)>0:0===n(t,t))&&(r=a,o=t,i=!0)}}else for(const n of t)(i?e(n,r)>0:0===e(n,n))&&(r=n,i=!0);return r}function at(t,n,e){if(t=Float64Array.from(function*(t,n){if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&(yield n);else{let e=-1;for(let r of t)null!=(r=n(r,++e,t))&&(r=+r)>=r&&(yield r)}}(t,e)),(r=t.length)&&!isNaN(n=+n)){if(n<=0||r<2)return nt(t);if(n>=1)return J(t);var r,i=(r-1)*n,o=Math.floor(i),a=J(rt(t,o).subarray(0,o+1));return a+(nt(t.subarray(o+1))-a)*(i-o)}}function ut(t,n,e=o){if((r=t.length)&&!isNaN(n=+n)){if(n<=0||r<2)return+e(t[0],0,t);if(n>=1)return+e(t[r-1],r-1,t);var r,i=(r-1)*n,a=Math.floor(i),u=+e(t[a],a,t);return u+(+e(t[a+1],a+1,t)-u)*(i-a)}}function ct(t,n,e=o){if(!isNaN(n=+n)){if(r=Float64Array.from(t,((n,r)=>o(e(t[r],r,t)))),n<=0)return et(r);if(n>=1)return tt(r);var r,i=Uint32Array.from(t,((t,n)=>n)),a=r.length-1,u=Math.floor(a*n);return rt(i,u,0,a,((t,n)=>O(r[t],r[n]))),(u=ot(i.subarray(0,u+1),(t=>r[t])))>=0?u:-1}}function ft(t){return Array.from(function*(t){for(const n of t)yield*n}(t))}function st(t,n){return[t,n]}function lt(t,n,e){t=+t,n=+n,e=(i=arguments.length)<2?(n=t,t=0,1):i<3?1:+e;for(var r=-1,i=0|Math.max(0,Math.ceil((n-t)/e)),o=new Array(i);++r+t(n)}function kt(t,n){return n=Math.max(0,t.bandwidth()-2*n)/2,t.round()&&(n=Math.round(n)),e=>+t(e)+n}function Ct(){return!this.__axis}function Pt(t,n){var e=[],r=null,i=null,o=6,a=6,u=3,c="undefined"!=typeof window&&window.devicePixelRatio>1?0:.5,f=t===xt||t===Tt?-1:1,s=t===Tt||t===wt?"x":"y",l=t===xt||t===Mt?St:Et;function h(h){var d=null==r?n.ticks?n.ticks.apply(n,e):n.domain():r,p=null==i?n.tickFormat?n.tickFormat.apply(n,e):mt:i,g=Math.max(o,0)+u,y=n.range(),v=+y[0]+c,_=+y[y.length-1]+c,b=(n.bandwidth?kt:Nt)(n.copy(),c),m=h.selection?h.selection():h,x=m.selectAll(".domain").data([null]),w=m.selectAll(".tick").data(d,n).order(),M=w.exit(),T=w.enter().append("g").attr("class","tick"),A=w.select("line"),S=w.select("text");x=x.merge(x.enter().insert("path",".tick").attr("class","domain").attr("stroke","currentColor")),w=w.merge(T),A=A.merge(T.append("line").attr("stroke","currentColor").attr(s+"2",f*o)),S=S.merge(T.append("text").attr("fill","currentColor").attr(s,f*g).attr("dy",t===xt?"0em":t===Mt?"0.71em":"0.32em")),h!==m&&(x=x.transition(h),w=w.transition(h),A=A.transition(h),S=S.transition(h),M=M.transition(h).attr("opacity",At).attr("transform",(function(t){return isFinite(t=b(t))?l(t+c):this.getAttribute("transform")})),T.attr("opacity",At).attr("transform",(function(t){var n=this.parentNode.__axis;return l((n&&isFinite(n=n(t))?n:b(t))+c)}))),M.remove(),x.attr("d",t===Tt||t===wt?a?"M"+f*a+","+v+"H"+c+"V"+_+"H"+f*a:"M"+c+","+v+"V"+_:a?"M"+v+","+f*a+"V"+c+"H"+_+"V"+f*a:"M"+v+","+c+"H"+_),w.attr("opacity",1).attr("transform",(function(t){return l(b(t)+c)})),A.attr(s+"2",f*o),S.attr(s,f*g).text(p),m.filter(Ct).attr("fill","none").attr("font-size",10).attr("font-family","sans-serif").attr("text-anchor",t===wt?"start":t===Tt?"end":"middle"),m.each((function(){this.__axis=b}))}return h.scale=function(t){return arguments.length?(n=t,h):n},h.ticks=function(){return e=Array.from(arguments),h},h.tickArguments=function(t){return arguments.length?(e=null==t?[]:Array.from(t),h):e.slice()},h.tickValues=function(t){return arguments.length?(r=null==t?null:Array.from(t),h):r&&r.slice()},h.tickFormat=function(t){return arguments.length?(i=t,h):i},h.tickSize=function(t){return arguments.length?(o=a=+t,h):o},h.tickSizeInner=function(t){return arguments.length?(o=+t,h):o},h.tickSizeOuter=function(t){return arguments.length?(a=+t,h):a},h.tickPadding=function(t){return arguments.length?(u=+t,h):u},h.offset=function(t){return arguments.length?(c=+t,h):c},h}var zt={value:()=>{}};function $t(){for(var t,n=0,e=arguments.length,r={};n=0&&(n=t.slice(e+1),t=t.slice(0,e)),t&&!r.hasOwnProperty(t))throw new Error("unknown type: "+t);return{type:t,name:n}}))),a=-1,u=o.length;if(!(arguments.length<2)){if(null!=n&&"function"!=typeof n)throw new Error("invalid callback: "+n);for(;++a0)for(var e,r,i=new Array(e),o=0;o=0&&"xmlns"!==(n=t.slice(0,e))&&(t=t.slice(e+1)),Ut.hasOwnProperty(n)?{space:Ut[n],local:t}:t}function Ot(t){return function(){var n=this.ownerDocument,e=this.namespaceURI;return e===qt&&n.documentElement.namespaceURI===qt?n.createElement(t):n.createElementNS(e,t)}}function Bt(t){return function(){return this.ownerDocument.createElementNS(t.space,t.local)}}function Yt(t){var n=It(t);return(n.local?Bt:Ot)(n)}function Lt(){}function jt(t){return null==t?Lt:function(){return this.querySelector(t)}}function Ht(t){return null==t?[]:Array.isArray(t)?t:Array.from(t)}function Xt(){return[]}function Gt(t){return null==t?Xt:function(){return this.querySelectorAll(t)}}function Vt(t){return function(){return this.matches(t)}}function Wt(t){return function(n){return n.matches(t)}}var Zt=Array.prototype.find;function Kt(){return this.firstElementChild}var Qt=Array.prototype.filter;function Jt(){return Array.from(this.children)}function tn(t){return new Array(t.length)}function nn(t,n){this.ownerDocument=t.ownerDocument,this.namespaceURI=t.namespaceURI,this._next=null,this._parent=t,this.__data__=n}function en(t,n,e,r,i,o){for(var a,u=0,c=n.length,f=o.length;un?1:t>=n?0:NaN}function cn(t){return function(){this.removeAttribute(t)}}function fn(t){return function(){this.removeAttributeNS(t.space,t.local)}}function sn(t,n){return function(){this.setAttribute(t,n)}}function ln(t,n){return function(){this.setAttributeNS(t.space,t.local,n)}}function hn(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttribute(t):this.setAttribute(t,e)}}function dn(t,n){return function(){var e=n.apply(this,arguments);null==e?this.removeAttributeNS(t.space,t.local):this.setAttributeNS(t.space,t.local,e)}}function pn(t){return t.ownerDocument&&t.ownerDocument.defaultView||t.document&&t||t.defaultView}function gn(t){return function(){this.style.removeProperty(t)}}function yn(t,n,e){return function(){this.style.setProperty(t,n,e)}}function vn(t,n,e){return function(){var r=n.apply(this,arguments);null==r?this.style.removeProperty(t):this.style.setProperty(t,r,e)}}function _n(t,n){return t.style.getPropertyValue(n)||pn(t).getComputedStyle(t,null).getPropertyValue(n)}function bn(t){return function(){delete this[t]}}function mn(t,n){return function(){this[t]=n}}function xn(t,n){return function(){var e=n.apply(this,arguments);null==e?delete this[t]:this[t]=e}}function wn(t){return t.trim().split(/^|\s+/)}function Mn(t){return t.classList||new Tn(t)}function Tn(t){this._node=t,this._names=wn(t.getAttribute("class")||"")}function An(t,n){for(var e=Mn(t),r=-1,i=n.length;++r=0&&(this._names.splice(n,1),this._node.setAttribute("class",this._names.join(" ")))},contains:function(t){return this._names.indexOf(t)>=0}};var Gn=[null];function Vn(t,n){this._groups=t,this._parents=n}function Wn(){return new Vn([[document.documentElement]],Gn)}function Zn(t){return"string"==typeof t?new Vn([[document.querySelector(t)]],[document.documentElement]):new Vn([[t]],Gn)}Vn.prototype=Wn.prototype={constructor:Vn,select:function(t){"function"!=typeof t&&(t=jt(t));for(var n=this._groups,e=n.length,r=new Array(e),i=0;i=m&&(m=b+1);!(_=y[m])&&++m=0;)(r=i[o])&&(a&&4^r.compareDocumentPosition(a)&&a.parentNode.insertBefore(r,a),a=r);return this},sort:function(t){function n(n,e){return n&&e?t(n.__data__,e.__data__):!n-!e}t||(t=un);for(var e=this._groups,r=e.length,i=new Array(r),o=0;o1?this.each((null==n?gn:"function"==typeof n?vn:yn)(t,n,null==e?"":e)):_n(this.node(),t)},property:function(t,n){return arguments.length>1?this.each((null==n?bn:"function"==typeof n?xn:mn)(t,n)):this.node()[t]},classed:function(t,n){var e=wn(t+"");if(arguments.length<2){for(var r=Mn(this.node()),i=-1,o=e.length;++i=0&&(n=t.slice(e+1),t=t.slice(0,e)),{type:t,name:n}}))}(t+""),a=o.length;if(!(arguments.length<2)){for(u=n?Ln:Yn,r=0;r()=>t;function fe(t,{sourceEvent:n,subject:e,target:r,identifier:i,active:o,x:a,y:u,dx:c,dy:f,dispatch:s}){Object.defineProperties(this,{type:{value:t,enumerable:!0,configurable:!0},sourceEvent:{value:n,enumerable:!0,configurable:!0},subject:{value:e,enumerable:!0,configurable:!0},target:{value:r,enumerable:!0,configurable:!0},identifier:{value:i,enumerable:!0,configurable:!0},active:{value:o,enumerable:!0,configurable:!0},x:{value:a,enumerable:!0,configurable:!0},y:{value:u,enumerable:!0,configurable:!0},dx:{value:c,enumerable:!0,configurable:!0},dy:{value:f,enumerable:!0,configurable:!0},_:{value:s}})}function se(t){return!t.ctrlKey&&!t.button}function le(){return this.parentNode}function he(t,n){return null==n?{x:t.x,y:t.y}:n}function de(){return navigator.maxTouchPoints||"ontouchstart"in this}function pe(t,n,e){t.prototype=n.prototype=e,e.constructor=t}function ge(t,n){var e=Object.create(t.prototype);for(var r in n)e[r]=n[r];return e}function ye(){}fe.prototype.on=function(){var t=this._.on.apply(this._,arguments);return t===this._?this:t};var ve=.7,_e=1/ve,be="\\s*([+-]?\\d+)\\s*",me="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)\\s*",xe="\\s*([+-]?(?:\\d*\\.)?\\d+(?:[eE][+-]?\\d+)?)%\\s*",we=/^#([0-9a-f]{3,8})$/,Me=new RegExp(`^rgb\\(${be},${be},${be}\\)$`),Te=new RegExp(`^rgb\\(${xe},${xe},${xe}\\)$`),Ae=new RegExp(`^rgba\\(${be},${be},${be},${me}\\)$`),Se=new RegExp(`^rgba\\(${xe},${xe},${xe},${me}\\)$`),Ee=new RegExp(`^hsl\\(${me},${xe},${xe}\\)$`),Ne=new RegExp(`^hsla\\(${me},${xe},${xe},${me}\\)$`),ke={aliceblue:15792383,antiquewhite:16444375,aqua:65535,aquamarine:8388564,azure:15794175,beige:16119260,bisque:16770244,black:0,blanchedalmond:16772045,blue:255,blueviolet:9055202,brown:10824234,burlywood:14596231,cadetblue:6266528,chartreuse:8388352,chocolate:13789470,coral:16744272,cornflowerblue:6591981,cornsilk:16775388,crimson:14423100,cyan:65535,darkblue:139,darkcyan:35723,darkgoldenrod:12092939,darkgray:11119017,darkgreen:25600,darkgrey:11119017,darkkhaki:12433259,darkmagenta:9109643,darkolivegreen:5597999,darkorange:16747520,darkorchid:10040012,darkred:9109504,darksalmon:15308410,darkseagreen:9419919,darkslateblue:4734347,darkslategray:3100495,darkslategrey:3100495,darkturquoise:52945,darkviolet:9699539,deeppink:16716947,deepskyblue:49151,dimgray:6908265,dimgrey:6908265,dodgerblue:2003199,firebrick:11674146,floralwhite:16775920,forestgreen:2263842,fuchsia:16711935,gainsboro:14474460,ghostwhite:16316671,gold:16766720,goldenrod:14329120,gray:8421504,green:32768,greenyellow:11403055,grey:8421504,honeydew:15794160,hotpink:16738740,indianred:13458524,indigo:4915330,ivory:16777200,khaki:15787660,lavender:15132410,lavenderblush:16773365,lawngreen:8190976,lemonchiffon:16775885,lightblue:11393254,lightcoral:15761536,lightcyan:14745599,lightgoldenrodyellow:16448210,lightgray:13882323,lightgreen:9498256,lightgrey:13882323,lightpink:16758465,lightsalmon:16752762,lightseagreen:2142890,lightskyblue:8900346,lightslategray:7833753,lightslategrey:7833753,lightsteelblue:11584734,lightyellow:16777184,lime:65280,limegreen:3329330,linen:16445670,magenta:16711935,maroon:8388608,mediumaquamarine:6737322,mediumblue:205,mediumorchid:12211667,mediumpurple:9662683,mediumseagreen:3978097,mediumslateblue:8087790,mediumspringgreen:64154,mediumturquoise:4772300,mediumvioletred:13047173,midnightblue:1644912,mintcream:16121850,mistyrose:16770273,moccasin:16770229,navajowhite:16768685,navy:128,oldlace:16643558,olive:8421376,olivedrab:7048739,orange:16753920,orangered:16729344,orchid:14315734,palegoldenrod:15657130,palegreen:10025880,paleturquoise:11529966,palevioletred:14381203,papayawhip:16773077,peachpuff:16767673,peru:13468991,pink:16761035,plum:14524637,powderblue:11591910,purple:8388736,rebeccapurple:6697881,red:16711680,rosybrown:12357519,royalblue:4286945,saddlebrown:9127187,salmon:16416882,sandybrown:16032864,seagreen:3050327,seashell:16774638,sienna:10506797,silver:12632256,skyblue:8900331,slateblue:6970061,slategray:7372944,slategrey:7372944,snow:16775930,springgreen:65407,steelblue:4620980,tan:13808780,teal:32896,thistle:14204888,tomato:16737095,turquoise:4251856,violet:15631086,wheat:16113331,white:16777215,whitesmoke:16119285,yellow:16776960,yellowgreen:10145074};function Ce(){return this.rgb().formatHex()}function Pe(){return this.rgb().formatRgb()}function ze(t){var n,e;return t=(t+"").trim().toLowerCase(),(n=we.exec(t))?(e=n[1].length,n=parseInt(n[1],16),6===e?$e(n):3===e?new qe(n>>8&15|n>>4&240,n>>4&15|240&n,(15&n)<<4|15&n,1):8===e?De(n>>24&255,n>>16&255,n>>8&255,(255&n)/255):4===e?De(n>>12&15|n>>8&240,n>>8&15|n>>4&240,n>>4&15|240&n,((15&n)<<4|15&n)/255):null):(n=Me.exec(t))?new qe(n[1],n[2],n[3],1):(n=Te.exec(t))?new qe(255*n[1]/100,255*n[2]/100,255*n[3]/100,1):(n=Ae.exec(t))?De(n[1],n[2],n[3],n[4]):(n=Se.exec(t))?De(255*n[1]/100,255*n[2]/100,255*n[3]/100,n[4]):(n=Ee.exec(t))?Le(n[1],n[2]/100,n[3]/100,1):(n=Ne.exec(t))?Le(n[1],n[2]/100,n[3]/100,n[4]):ke.hasOwnProperty(t)?$e(ke[t]):"transparent"===t?new qe(NaN,NaN,NaN,0):null}function $e(t){return new qe(t>>16&255,t>>8&255,255&t,1)}function De(t,n,e,r){return r<=0&&(t=n=e=NaN),new qe(t,n,e,r)}function Re(t){return t instanceof ye||(t=ze(t)),t?new qe((t=t.rgb()).r,t.g,t.b,t.opacity):new qe}function Fe(t,n,e,r){return 1===arguments.length?Re(t):new qe(t,n,e,null==r?1:r)}function qe(t,n,e,r){this.r=+t,this.g=+n,this.b=+e,this.opacity=+r}function Ue(){return`#${Ye(this.r)}${Ye(this.g)}${Ye(this.b)}`}function Ie(){const t=Oe(this.opacity);return`${1===t?"rgb(":"rgba("}${Be(this.r)}, ${Be(this.g)}, ${Be(this.b)}${1===t?")":`, ${t})`}`}function Oe(t){return isNaN(t)?1:Math.max(0,Math.min(1,t))}function Be(t){return Math.max(0,Math.min(255,Math.round(t)||0))}function Ye(t){return((t=Be(t))<16?"0":"")+t.toString(16)}function Le(t,n,e,r){return r<=0?t=n=e=NaN:e<=0||e>=1?t=n=NaN:n<=0&&(t=NaN),new Xe(t,n,e,r)}function je(t){if(t instanceof Xe)return new Xe(t.h,t.s,t.l,t.opacity);if(t instanceof ye||(t=ze(t)),!t)return new Xe;if(t instanceof Xe)return t;var n=(t=t.rgb()).r/255,e=t.g/255,r=t.b/255,i=Math.min(n,e,r),o=Math.max(n,e,r),a=NaN,u=o-i,c=(o+i)/2;return u?(a=n===o?(e-r)/u+6*(e0&&c<1?0:a,new Xe(a,u,c,t.opacity)}function He(t,n,e,r){return 1===arguments.length?je(t):new Xe(t,n,e,null==r?1:r)}function Xe(t,n,e,r){this.h=+t,this.s=+n,this.l=+e,this.opacity=+r}function Ge(t){return(t=(t||0)%360)<0?t+360:t}function Ve(t){return Math.max(0,Math.min(1,t||0))}function We(t,n,e){return 255*(t<60?n+(e-n)*t/60:t<180?e:t<240?n+(e-n)*(240-t)/60:n)}pe(ye,ze,{copy(t){return Object.assign(new this.constructor,this,t)},displayable(){return this.rgb().displayable()},hex:Ce,formatHex:Ce,formatHex8:function(){return this.rgb().formatHex8()},formatHsl:function(){return je(this).formatHsl()},formatRgb:Pe,toString:Pe}),pe(qe,Fe,ge(ye,{brighter(t){return t=null==t?_e:Math.pow(_e,t),new qe(this.r*t,this.g*t,this.b*t,this.opacity)},darker(t){return t=null==t?ve:Math.pow(ve,t),new qe(this.r*t,this.g*t,this.b*t,this.opacity)},rgb(){return this},clamp(){return new qe(Be(this.r),Be(this.g),Be(this.b),Oe(this.opacity))},displayable(){return-.5<=this.r&&this.r<255.5&&-.5<=this.g&&this.g<255.5&&-.5<=this.b&&this.b<255.5&&0<=this.opacity&&this.opacity<=1},hex:Ue,formatHex:Ue,formatHex8:function(){return`#${Ye(this.r)}${Ye(this.g)}${Ye(this.b)}${Ye(255*(isNaN(this.opacity)?1:this.opacity))}`},formatRgb:Ie,toString:Ie})),pe(Xe,He,ge(ye,{brighter(t){return t=null==t?_e:Math.pow(_e,t),new Xe(this.h,this.s,this.l*t,this.opacity)},darker(t){return t=null==t?ve:Math.pow(ve,t),new Xe(this.h,this.s,this.l*t,this.opacity)},rgb(){var t=this.h%360+360*(this.h<0),n=isNaN(t)||isNaN(this.s)?0:this.s,e=this.l,r=e+(e<.5?e:1-e)*n,i=2*e-r;return new qe(We(t>=240?t-240:t+120,i,r),We(t,i,r),We(t<120?t+240:t-120,i,r),this.opacity)},clamp(){return new Xe(Ge(this.h),Ve(this.s),Ve(this.l),Oe(this.opacity))},displayable(){return(0<=this.s&&this.s<=1||isNaN(this.s))&&0<=this.l&&this.l<=1&&0<=this.opacity&&this.opacity<=1},formatHsl(){const t=Oe(this.opacity);return`${1===t?"hsl(":"hsla("}${Ge(this.h)}, ${100*Ve(this.s)}%, ${100*Ve(this.l)}%${1===t?")":`, ${t})`}`}}));const Ze=Math.PI/180,Ke=180/Math.PI,Qe=.96422,Je=1,tr=.82521,nr=4/29,er=6/29,rr=3*er*er,ir=er*er*er;function or(t){if(t instanceof ur)return new ur(t.l,t.a,t.b,t.opacity);if(t instanceof pr)return gr(t);t instanceof qe||(t=Re(t));var n,e,r=lr(t.r),i=lr(t.g),o=lr(t.b),a=cr((.2225045*r+.7168786*i+.0606169*o)/Je);return r===i&&i===o?n=e=a:(n=cr((.4360747*r+.3850649*i+.1430804*o)/Qe),e=cr((.0139322*r+.0971045*i+.7141733*o)/tr)),new ur(116*a-16,500*(n-a),200*(a-e),t.opacity)}function ar(t,n,e,r){return 1===arguments.length?or(t):new ur(t,n,e,null==r?1:r)}function ur(t,n,e,r){this.l=+t,this.a=+n,this.b=+e,this.opacity=+r}function cr(t){return t>ir?Math.pow(t,1/3):t/rr+nr}function fr(t){return t>er?t*t*t:rr*(t-nr)}function sr(t){return 255*(t<=.0031308?12.92*t:1.055*Math.pow(t,1/2.4)-.055)}function lr(t){return(t/=255)<=.04045?t/12.92:Math.pow((t+.055)/1.055,2.4)}function hr(t){if(t instanceof pr)return new pr(t.h,t.c,t.l,t.opacity);if(t instanceof ur||(t=or(t)),0===t.a&&0===t.b)return new pr(NaN,0=1?(e=1,n-1):Math.floor(e*n),i=t[r],o=t[r+1],a=r>0?t[r-1]:2*i-o,u=r()=>t;function Cr(t,n){return function(e){return t+e*n}}function Pr(t,n){var e=n-t;return e?Cr(t,e>180||e<-180?e-360*Math.round(e/360):e):kr(isNaN(t)?n:t)}function zr(t){return 1==(t=+t)?$r:function(n,e){return e-n?function(t,n,e){return t=Math.pow(t,e),n=Math.pow(n,e)-t,e=1/e,function(r){return Math.pow(t+r*n,e)}}(n,e,t):kr(isNaN(n)?e:n)}}function $r(t,n){var e=n-t;return e?Cr(t,e):kr(isNaN(t)?n:t)}var Dr=function t(n){var e=zr(n);function r(t,n){var r=e((t=Fe(t)).r,(n=Fe(n)).r),i=e(t.g,n.g),o=e(t.b,n.b),a=$r(t.opacity,n.opacity);return function(n){return t.r=r(n),t.g=i(n),t.b=o(n),t.opacity=a(n),t+""}}return r.gamma=t,r}(1);function Rr(t){return function(n){var e,r,i=n.length,o=new Array(i),a=new Array(i),u=new Array(i);for(e=0;eo&&(i=n.slice(o,i),u[a]?u[a]+=i:u[++a]=i),(e=e[0])===(r=r[0])?u[a]?u[a]+=r:u[++a]=r:(u[++a]=null,c.push({i:a,x:Yr(e,r)})),o=Hr.lastIndex;return o180?n+=360:n-t>180&&(t+=360),o.push({i:e.push(i(e)+"rotate(",null,r)-2,x:Yr(t,n)})):n&&e.push(i(e)+"rotate("+n+r)}(o.rotate,a.rotate,u,c),function(t,n,e,o){t!==n?o.push({i:e.push(i(e)+"skewX(",null,r)-2,x:Yr(t,n)}):n&&e.push(i(e)+"skewX("+n+r)}(o.skewX,a.skewX,u,c),function(t,n,e,r,o,a){if(t!==e||n!==r){var u=o.push(i(o)+"scale(",null,",",null,")");a.push({i:u-4,x:Yr(t,e)},{i:u-2,x:Yr(n,r)})}else 1===e&&1===r||o.push(i(o)+"scale("+e+","+r+")")}(o.scaleX,o.scaleY,a.scaleX,a.scaleY,u,c),o=a=null,function(t){for(var n,e=-1,r=c.length;++e=0&&n._call.call(void 0,t),n=n._next;--yi}function Ci(){xi=(mi=Mi.now())+wi,yi=vi=0;try{ki()}finally{yi=0,function(){var t,n,e=pi,r=1/0;for(;e;)e._call?(r>e._time&&(r=e._time),t=e,e=e._next):(n=e._next,e._next=null,e=t?t._next=n:pi=n);gi=t,zi(r)}(),xi=0}}function Pi(){var t=Mi.now(),n=t-mi;n>bi&&(wi-=n,mi=t)}function zi(t){yi||(vi&&(vi=clearTimeout(vi)),t-xi>24?(t<1/0&&(vi=setTimeout(Ci,t-Mi.now()-wi)),_i&&(_i=clearInterval(_i))):(_i||(mi=Mi.now(),_i=setInterval(Pi,bi)),yi=1,Ti(Ci)))}function $i(t,n,e){var r=new Ei;return n=null==n?0:+n,r.restart((e=>{r.stop(),t(e+n)}),n,e),r}Ei.prototype=Ni.prototype={constructor:Ei,restart:function(t,n,e){if("function"!=typeof t)throw new TypeError("callback is not a function");e=(null==e?Ai():+e)+(null==n?0:+n),this._next||gi===this||(gi?gi._next=this:pi=this,gi=this),this._call=t,this._time=e,zi()},stop:function(){this._call&&(this._call=null,this._time=1/0,zi())}};var Di=$t("start","end","cancel","interrupt"),Ri=[],Fi=0,qi=1,Ui=2,Ii=3,Oi=4,Bi=5,Yi=6;function Li(t,n,e,r,i,o){var a=t.__transition;if(a){if(e in a)return}else t.__transition={};!function(t,n,e){var r,i=t.__transition;function o(t){e.state=qi,e.timer.restart(a,e.delay,e.time),e.delay<=t&&a(t-e.delay)}function a(o){var f,s,l,h;if(e.state!==qi)return c();for(f in i)if((h=i[f]).name===e.name){if(h.state===Ii)return $i(a);h.state===Oi?(h.state=Yi,h.timer.stop(),h.on.call("interrupt",t,t.__data__,h.index,h.group),delete i[f]):+fFi)throw new Error("too late; already scheduled");return e}function Hi(t,n){var e=Xi(t,n);if(e.state>Ii)throw new Error("too late; already running");return e}function Xi(t,n){var e=t.__transition;if(!e||!(e=e[n]))throw new Error("transition not found");return e}function Gi(t,n){var e,r,i,o=t.__transition,a=!0;if(o){for(i in n=null==n?null:n+"",o)(e=o[i]).name===n?(r=e.state>Ui&&e.state=0&&(t=t.slice(0,n)),!t||"start"===t}))}(n)?ji:Hi;return function(){var a=o(this,t),u=a.on;u!==r&&(i=(r=u).copy()).on(n,e),a.on=i}}(e,t,n))},attr:function(t,n){var e=It(t),r="transform"===e?ni:Ki;return this.attrTween(t,"function"==typeof n?(e.local?ro:eo)(e,r,Zi(this,"attr."+t,n)):null==n?(e.local?Ji:Qi)(e):(e.local?no:to)(e,r,n))},attrTween:function(t,n){var e="attr."+t;if(arguments.length<2)return(e=this.tween(e))&&e._value;if(null==n)return this.tween(e,null);if("function"!=typeof n)throw new Error;var r=It(t);return this.tween(e,(r.local?io:oo)(r,n))},style:function(t,n,e){var r="transform"==(t+="")?ti:Ki;return null==n?this.styleTween(t,function(t,n){var e,r,i;return function(){var o=_n(this,t),a=(this.style.removeProperty(t),_n(this,t));return o===a?null:o===e&&a===r?i:i=n(e=o,r=a)}}(t,r)).on("end.style."+t,lo(t)):"function"==typeof n?this.styleTween(t,function(t,n,e){var r,i,o;return function(){var a=_n(this,t),u=e(this),c=u+"";return null==u&&(this.style.removeProperty(t),c=u=_n(this,t)),a===c?null:a===r&&c===i?o:(i=c,o=n(r=a,u))}}(t,r,Zi(this,"style."+t,n))).each(function(t,n){var e,r,i,o,a="style."+n,u="end."+a;return function(){var c=Hi(this,t),f=c.on,s=null==c.value[a]?o||(o=lo(n)):void 0;f===e&&i===s||(r=(e=f).copy()).on(u,i=s),c.on=r}}(this._id,t)):this.styleTween(t,function(t,n,e){var r,i,o=e+"";return function(){var a=_n(this,t);return a===o?null:a===r?i:i=n(r=a,e)}}(t,r,n),e).on("end.style."+t,null)},styleTween:function(t,n,e){var r="style."+(t+="");if(arguments.length<2)return(r=this.tween(r))&&r._value;if(null==n)return this.tween(r,null);if("function"!=typeof n)throw new Error;return this.tween(r,function(t,n,e){var r,i;function o(){var o=n.apply(this,arguments);return o!==i&&(r=(i=o)&&function(t,n,e){return function(r){this.style.setProperty(t,n.call(this,r),e)}}(t,o,e)),r}return o._value=n,o}(t,n,null==e?"":e))},text:function(t){return this.tween("text","function"==typeof t?function(t){return function(){var n=t(this);this.textContent=null==n?"":n}}(Zi(this,"text",t)):function(t){return function(){this.textContent=t}}(null==t?"":t+""))},textTween:function(t){var n="text";if(arguments.length<1)return(n=this.tween(n))&&n._value;if(null==t)return this.tween(n,null);if("function"!=typeof t)throw new Error;return this.tween(n,function(t){var n,e;function r(){var r=t.apply(this,arguments);return r!==e&&(n=(e=r)&&function(t){return function(n){this.textContent=t.call(this,n)}}(r)),n}return r._value=t,r}(t))},remove:function(){return this.on("end.remove",function(t){return function(){var n=this.parentNode;for(var e in this.__transition)if(+e!==t)return;n&&n.removeChild(this)}}(this._id))},tween:function(t,n){var e=this._id;if(t+="",arguments.length<2){for(var r,i=Xi(this.node(),e).tween,o=0,a=i.length;o()=>t;function Qo(t,{sourceEvent:n,target:e,selection:r,mode:i,dispatch:o}){Object.defineProperties(this,{type:{value:t,enumerable:!0,configurable:!0},sourceEvent:{value:n,enumerable:!0,configurable:!0},target:{value:e,enumerable:!0,configurable:!0},selection:{value:r,enumerable:!0,configurable:!0},mode:{value:i,enumerable:!0,configurable:!0},_:{value:o}})}function Jo(t){t.preventDefault(),t.stopImmediatePropagation()}var ta={name:"drag"},na={name:"space"},ea={name:"handle"},ra={name:"center"};const{abs:ia,max:oa,min:aa}=Math;function ua(t){return[+t[0],+t[1]]}function ca(t){return[ua(t[0]),ua(t[1])]}var fa={name:"x",handles:["w","e"].map(va),input:function(t,n){return null==t?null:[[+t[0],n[0][1]],[+t[1],n[1][1]]]},output:function(t){return t&&[t[0][0],t[1][0]]}},sa={name:"y",handles:["n","s"].map(va),input:function(t,n){return null==t?null:[[n[0][0],+t[0]],[n[1][0],+t[1]]]},output:function(t){return t&&[t[0][1],t[1][1]]}},la={name:"xy",handles:["n","w","e","s","nw","ne","sw","se"].map(va),input:function(t){return null==t?null:ca(t)},output:function(t){return t}},ha={overlay:"crosshair",selection:"move",n:"ns-resize",e:"ew-resize",s:"ns-resize",w:"ew-resize",nw:"nwse-resize",ne:"nesw-resize",se:"nwse-resize",sw:"nesw-resize"},da={e:"w",w:"e",nw:"ne",ne:"nw",se:"sw",sw:"se"},pa={n:"s",s:"n",nw:"sw",ne:"se",se:"ne",sw:"nw"},ga={overlay:1,selection:1,n:null,e:1,s:null,w:-1,nw:-1,ne:1,se:1,sw:-1},ya={overlay:1,selection:1,n:-1,e:null,s:1,w:null,nw:-1,ne:-1,se:1,sw:1};function va(t){return{type:t}}function _a(t){return!t.ctrlKey&&!t.button}function ba(){var t=this.ownerSVGElement||this;return t.hasAttribute("viewBox")?[[(t=t.viewBox.baseVal).x,t.y],[t.x+t.width,t.y+t.height]]:[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]}function ma(){return navigator.maxTouchPoints||"ontouchstart"in this}function xa(t){for(;!t.__brush;)if(!(t=t.parentNode))return;return t.__brush}function wa(t){var n,e=ba,r=_a,i=ma,o=!0,a=$t("start","brush","end"),u=6;function c(n){var e=n.property("__brush",g).selectAll(".overlay").data([va("overlay")]);e.enter().append("rect").attr("class","overlay").attr("pointer-events","all").attr("cursor",ha.overlay).merge(e).each((function(){var t=xa(this).extent;Zn(this).attr("x",t[0][0]).attr("y",t[0][1]).attr("width",t[1][0]-t[0][0]).attr("height",t[1][1]-t[0][1])})),n.selectAll(".selection").data([va("selection")]).enter().append("rect").attr("class","selection").attr("cursor",ha.selection).attr("fill","#777").attr("fill-opacity",.3).attr("stroke","#fff").attr("shape-rendering","crispEdges");var r=n.selectAll(".handle").data(t.handles,(function(t){return t.type}));r.exit().remove(),r.enter().append("rect").attr("class",(function(t){return"handle handle--"+t.type})).attr("cursor",(function(t){return ha[t.type]})),n.each(f).attr("fill","none").attr("pointer-events","all").on("mousedown.brush",h).filter(i).on("touchstart.brush",h).on("touchmove.brush",d).on("touchend.brush touchcancel.brush",p).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function f(){var t=Zn(this),n=xa(this).selection;n?(t.selectAll(".selection").style("display",null).attr("x",n[0][0]).attr("y",n[0][1]).attr("width",n[1][0]-n[0][0]).attr("height",n[1][1]-n[0][1]),t.selectAll(".handle").style("display",null).attr("x",(function(t){return"e"===t.type[t.type.length-1]?n[1][0]-u/2:n[0][0]-u/2})).attr("y",(function(t){return"s"===t.type[0]?n[1][1]-u/2:n[0][1]-u/2})).attr("width",(function(t){return"n"===t.type||"s"===t.type?n[1][0]-n[0][0]+u:u})).attr("height",(function(t){return"e"===t.type||"w"===t.type?n[1][1]-n[0][1]+u:u}))):t.selectAll(".selection,.handle").style("display","none").attr("x",null).attr("y",null).attr("width",null).attr("height",null)}function s(t,n,e){var r=t.__brush.emitter;return!r||e&&r.clean?new l(t,n,e):r}function l(t,n,e){this.that=t,this.args=n,this.state=t.__brush,this.active=0,this.clean=e}function h(e){if((!n||e.touches)&&r.apply(this,arguments)){var i,a,u,c,l,h,d,p,g,y,v,_=this,b=e.target.__data__.type,m="selection"===(o&&e.metaKey?b="overlay":b)?ta:o&&e.altKey?ra:ea,x=t===sa?null:ga[b],w=t===fa?null:ya[b],M=xa(_),T=M.extent,A=M.selection,S=T[0][0],E=T[0][1],N=T[1][0],k=T[1][1],C=0,P=0,z=x&&w&&o&&e.shiftKey,$=Array.from(e.touches||[e],(t=>{const n=t.identifier;return(t=ne(t,_)).point0=t.slice(),t.identifier=n,t}));Gi(_);var D=s(_,arguments,!0).beforestart();if("overlay"===b){A&&(g=!0);const n=[$[0],$[1]||$[0]];M.selection=A=[[i=t===sa?S:aa(n[0][0],n[1][0]),u=t===fa?E:aa(n[0][1],n[1][1])],[l=t===sa?N:oa(n[0][0],n[1][0]),d=t===fa?k:oa(n[0][1],n[1][1])]],$.length>1&&I(e)}else i=A[0][0],u=A[0][1],l=A[1][0],d=A[1][1];a=i,c=u,h=l,p=d;var R=Zn(_).attr("pointer-events","none"),F=R.selectAll(".overlay").attr("cursor",ha[b]);if(e.touches)D.moved=U,D.ended=O;else{var q=Zn(e.view).on("mousemove.brush",U,!0).on("mouseup.brush",O,!0);o&&q.on("keydown.brush",(function(t){switch(t.keyCode){case 16:z=x&&w;break;case 18:m===ea&&(x&&(l=h-C*x,i=a+C*x),w&&(d=p-P*w,u=c+P*w),m=ra,I(t));break;case 32:m!==ea&&m!==ra||(x<0?l=h-C:x>0&&(i=a-C),w<0?d=p-P:w>0&&(u=c-P),m=na,F.attr("cursor",ha.selection),I(t));break;default:return}Jo(t)}),!0).on("keyup.brush",(function(t){switch(t.keyCode){case 16:z&&(y=v=z=!1,I(t));break;case 18:m===ra&&(x<0?l=h:x>0&&(i=a),w<0?d=p:w>0&&(u=c),m=ea,I(t));break;case 32:m===na&&(t.altKey?(x&&(l=h-C*x,i=a+C*x),w&&(d=p-P*w,u=c+P*w),m=ra):(x<0?l=h:x>0&&(i=a),w<0?d=p:w>0&&(u=c),m=ea),F.attr("cursor",ha[b]),I(t));break;default:return}Jo(t)}),!0),ae(e.view)}f.call(_),D.start(e,m.name)}function U(t){for(const n of t.changedTouches||[t])for(const t of $)t.identifier===n.identifier&&(t.cur=ne(n,_));if(z&&!y&&!v&&1===$.length){const t=$[0];ia(t.cur[0]-t[0])>ia(t.cur[1]-t[1])?v=!0:y=!0}for(const t of $)t.cur&&(t[0]=t.cur[0],t[1]=t.cur[1]);g=!0,Jo(t),I(t)}function I(t){const n=$[0],e=n.point0;var r;switch(C=n[0]-e[0],P=n[1]-e[1],m){case na:case ta:x&&(C=oa(S-i,aa(N-l,C)),a=i+C,h=l+C),w&&(P=oa(E-u,aa(k-d,P)),c=u+P,p=d+P);break;case ea:$[1]?(x&&(a=oa(S,aa(N,$[0][0])),h=oa(S,aa(N,$[1][0])),x=1),w&&(c=oa(E,aa(k,$[0][1])),p=oa(E,aa(k,$[1][1])),w=1)):(x<0?(C=oa(S-i,aa(N-i,C)),a=i+C,h=l):x>0&&(C=oa(S-l,aa(N-l,C)),a=i,h=l+C),w<0?(P=oa(E-u,aa(k-u,P)),c=u+P,p=d):w>0&&(P=oa(E-d,aa(k-d,P)),c=u,p=d+P));break;case ra:x&&(a=oa(S,aa(N,i-C*x)),h=oa(S,aa(N,l+C*x))),w&&(c=oa(E,aa(k,u-P*w)),p=oa(E,aa(k,d+P*w)))}ht+e))}function za(t,n){var e=0,r=null,i=null,o=null;function a(a){var u,c=a.length,f=new Array(c),s=Pa(0,c),l=new Array(c*c),h=new Array(c),d=0;a=Float64Array.from({length:c*c},n?(t,n)=>a[n%c][n/c|0]:(t,n)=>a[n/c|0][n%c]);for(let n=0;nr(f[t],f[n])));for(const e of s){const r=n;if(t){const t=Pa(1+~c,c).filter((t=>t<0?a[~t*c+e]:a[e*c+t]));i&&t.sort(((t,n)=>i(t<0?-a[~t*c+e]:a[e*c+t],n<0?-a[~n*c+e]:a[e*c+n])));for(const r of t)if(r<0){(l[~r*c+e]||(l[~r*c+e]={source:null,target:null})).target={index:e,startAngle:n,endAngle:n+=a[~r*c+e]*d,value:a[~r*c+e]}}else{(l[e*c+r]||(l[e*c+r]={source:null,target:null})).source={index:e,startAngle:n,endAngle:n+=a[e*c+r]*d,value:a[e*c+r]}}h[e]={index:e,startAngle:r,endAngle:n,value:f[e]}}else{const t=Pa(0,c).filter((t=>a[e*c+t]||a[t*c+e]));i&&t.sort(((t,n)=>i(a[e*c+t],a[e*c+n])));for(const r of t){let t;if(e=0))throw new Error(`invalid digits: ${t}`);if(n>15)return qa;const e=10**n;return function(t){this._+=t[0];for(let n=1,r=t.length;nRa)if(Math.abs(s*u-c*f)>Ra&&i){let h=e-o,d=r-a,p=u*u+c*c,g=h*h+d*d,y=Math.sqrt(p),v=Math.sqrt(l),_=i*Math.tan(($a-Math.acos((p+l-g)/(2*y*v)))/2),b=_/v,m=_/y;Math.abs(b-1)>Ra&&this._append`L${t+b*f},${n+b*s}`,this._append`A${i},${i},0,0,${+(s*h>f*d)},${this._x1=t+m*u},${this._y1=n+m*c}`}else this._append`L${this._x1=t},${this._y1=n}`;else;}arc(t,n,e,r,i,o){if(t=+t,n=+n,o=!!o,(e=+e)<0)throw new Error(`negative radius: ${e}`);let a=e*Math.cos(r),u=e*Math.sin(r),c=t+a,f=n+u,s=1^o,l=o?r-i:i-r;null===this._x1?this._append`M${c},${f}`:(Math.abs(this._x1-c)>Ra||Math.abs(this._y1-f)>Ra)&&this._append`L${c},${f}`,e&&(l<0&&(l=l%Da+Da),l>Fa?this._append`A${e},${e},0,1,${s},${t-a},${n-u}A${e},${e},0,1,${s},${this._x1=c},${this._y1=f}`:l>Ra&&this._append`A${e},${e},0,${+(l>=$a)},${s},${this._x1=t+e*Math.cos(i)},${this._y1=n+e*Math.sin(i)}`)}rect(t,n,e,r){this._append`M${this._x0=this._x1=+t},${this._y0=this._y1=+n}h${e=+e}v${+r}h${-e}Z`}toString(){return this._}};function Ia(){return new Ua}Ia.prototype=Ua.prototype;var Oa=Array.prototype.slice;function Ba(t){return function(){return t}}function Ya(t){return t.source}function La(t){return t.target}function ja(t){return t.radius}function Ha(t){return t.startAngle}function Xa(t){return t.endAngle}function Ga(){return 0}function Va(){return 10}function Wa(t){var n=Ya,e=La,r=ja,i=ja,o=Ha,a=Xa,u=Ga,c=null;function f(){var f,s=n.apply(this,arguments),l=e.apply(this,arguments),h=u.apply(this,arguments)/2,d=Oa.call(arguments),p=+r.apply(this,(d[0]=s,d)),g=o.apply(this,d)-Ea,y=a.apply(this,d)-Ea,v=+i.apply(this,(d[0]=l,d)),_=o.apply(this,d)-Ea,b=a.apply(this,d)-Ea;if(c||(c=f=Ia()),h>Ca&&(Ma(y-g)>2*h+Ca?y>g?(g+=h,y-=h):(g-=h,y+=h):g=y=(g+y)/2,Ma(b-_)>2*h+Ca?b>_?(_+=h,b-=h):(_-=h,b+=h):_=b=(_+b)/2),c.moveTo(p*Ta(g),p*Aa(g)),c.arc(0,0,p,g,y),g!==_||y!==b)if(t){var m=v-+t.apply(this,arguments),x=(_+b)/2;c.quadraticCurveTo(0,0,m*Ta(_),m*Aa(_)),c.lineTo(v*Ta(x),v*Aa(x)),c.lineTo(m*Ta(b),m*Aa(b))}else c.quadraticCurveTo(0,0,v*Ta(_),v*Aa(_)),c.arc(0,0,v,_,b);if(c.quadraticCurveTo(0,0,p*Ta(g),p*Aa(g)),c.closePath(),f)return c=null,f+""||null}return t&&(f.headRadius=function(n){return arguments.length?(t="function"==typeof n?n:Ba(+n),f):t}),f.radius=function(t){return arguments.length?(r=i="function"==typeof t?t:Ba(+t),f):r},f.sourceRadius=function(t){return arguments.length?(r="function"==typeof t?t:Ba(+t),f):r},f.targetRadius=function(t){return arguments.length?(i="function"==typeof t?t:Ba(+t),f):i},f.startAngle=function(t){return arguments.length?(o="function"==typeof t?t:Ba(+t),f):o},f.endAngle=function(t){return arguments.length?(a="function"==typeof t?t:Ba(+t),f):a},f.padAngle=function(t){return arguments.length?(u="function"==typeof t?t:Ba(+t),f):u},f.source=function(t){return arguments.length?(n=t,f):n},f.target=function(t){return arguments.length?(e=t,f):e},f.context=function(t){return arguments.length?(c=null==t?null:t,f):c},f}var Za=Array.prototype.slice;function Ka(t,n){return t-n}var Qa=t=>()=>t;function Ja(t,n){for(var e,r=-1,i=n.length;++rr!=d>r&&e<(h-f)*(r-s)/(d-s)+f&&(i=-i)}return i}function nu(t,n,e){var r,i,o,a;return function(t,n,e){return(n[0]-t[0])*(e[1]-t[1])==(e[0]-t[0])*(n[1]-t[1])}(t,n,e)&&(i=t[r=+(t[0]===n[0])],o=e[r],a=n[r],i<=o&&o<=a||a<=o&&o<=i)}function eu(){}var ru=[[],[[[1,1.5],[.5,1]]],[[[1.5,1],[1,1.5]]],[[[1.5,1],[.5,1]]],[[[1,.5],[1.5,1]]],[[[1,1.5],[.5,1]],[[1,.5],[1.5,1]]],[[[1,.5],[1,1.5]]],[[[1,.5],[.5,1]]],[[[.5,1],[1,.5]]],[[[1,1.5],[1,.5]]],[[[.5,1],[1,.5]],[[1.5,1],[1,1.5]]],[[[1.5,1],[1,.5]]],[[[.5,1],[1.5,1]]],[[[1,1.5],[1.5,1]]],[[[.5,1],[1,1.5]]],[]];function iu(){var t=1,n=1,e=K,r=u;function i(t){var n=e(t);if(Array.isArray(n))n=n.slice().sort(Ka);else{const e=M(t,ou);for(n=G(...Z(e[0],e[1],n),n);n[n.length-1]>=e[1];)n.pop();for(;n[1]o(t,n)))}function o(e,i){const o=null==i?NaN:+i;if(isNaN(o))throw new Error(`invalid value: ${i}`);var u=[],c=[];return function(e,r,i){var o,u,c,f,s,l,h=new Array,d=new Array;o=u=-1,f=au(e[0],r),ru[f<<1].forEach(p);for(;++o=r,ru[s<<2].forEach(p);for(;++o0?u.push([t]):c.push(t)})),c.forEach((function(t){for(var n,e=0,r=u.length;e0&&o0&&a=0&&o>=0))throw new Error("invalid size");return t=r,n=o,i},i.thresholds=function(t){return arguments.length?(e="function"==typeof t?t:Array.isArray(t)?Qa(Za.call(t)):Qa(t),i):e},i.smooth=function(t){return arguments.length?(r=t?u:eu,i):r===u},i}function ou(t){return isFinite(t)?t:NaN}function au(t,n){return null!=t&&+t>=n}function uu(t){return null==t||isNaN(t=+t)?-1/0:t}function cu(t,n,e,r){const i=r-n,o=e-n,a=isFinite(i)||isFinite(o)?i/o:Math.sign(i)/Math.sign(o);return isNaN(a)?t:t+a-.5}function fu(t){return t[0]}function su(t){return t[1]}function lu(){return 1}const hu=134217729,du=33306690738754706e-32;function pu(t,n,e,r,i){let o,a,u,c,f=n[0],s=r[0],l=0,h=0;s>f==s>-f?(o=f,f=n[++l]):(o=s,s=r[++h]);let d=0;if(lf==s>-f?(a=f+o,u=o-(a-f),f=n[++l]):(a=s+o,u=o-(a-s),s=r[++h]),o=a,0!==u&&(i[d++]=u);lf==s>-f?(a=o+f,c=a-o,u=o-(a-c)+(f-c),f=n[++l]):(a=o+s,c=a-o,u=o-(a-c)+(s-c),s=r[++h]),o=a,0!==u&&(i[d++]=u);for(;l=33306690738754716e-32*f?c:-function(t,n,e,r,i,o,a){let u,c,f,s,l,h,d,p,g,y,v,_,b,m,x,w,M,T;const A=t-i,S=e-i,E=n-o,N=r-o;m=A*N,h=hu*A,d=h-(h-A),p=A-d,h=hu*N,g=h-(h-N),y=N-g,x=p*y-(m-d*g-p*g-d*y),w=E*S,h=hu*E,d=h-(h-E),p=E-d,h=hu*S,g=h-(h-S),y=S-g,M=p*y-(w-d*g-p*g-d*y),v=x-M,l=x-v,_u[0]=x-(v+l)+(l-M),_=m+v,l=_-m,b=m-(_-l)+(v-l),v=b-w,l=b-v,_u[1]=b-(v+l)+(l-w),T=_+v,l=T-_,_u[2]=_-(T-l)+(v-l),_u[3]=T;let k=function(t,n){let e=n[0];for(let r=1;r=C||-k>=C)return k;if(l=t-A,u=t-(A+l)+(l-i),l=e-S,f=e-(S+l)+(l-i),l=n-E,c=n-(E+l)+(l-o),l=r-N,s=r-(N+l)+(l-o),0===u&&0===c&&0===f&&0===s)return k;if(C=vu*a+du*Math.abs(k),k+=A*s+N*u-(E*f+S*c),k>=C||-k>=C)return k;m=u*N,h=hu*u,d=h-(h-u),p=u-d,h=hu*N,g=h-(h-N),y=N-g,x=p*y-(m-d*g-p*g-d*y),w=c*S,h=hu*c,d=h-(h-c),p=c-d,h=hu*S,g=h-(h-S),y=S-g,M=p*y-(w-d*g-p*g-d*y),v=x-M,l=x-v,wu[0]=x-(v+l)+(l-M),_=m+v,l=_-m,b=m-(_-l)+(v-l),v=b-w,l=b-v,wu[1]=b-(v+l)+(l-w),T=_+v,l=T-_,wu[2]=_-(T-l)+(v-l),wu[3]=T;const P=pu(4,_u,4,wu,bu);m=A*s,h=hu*A,d=h-(h-A),p=A-d,h=hu*s,g=h-(h-s),y=s-g,x=p*y-(m-d*g-p*g-d*y),w=E*f,h=hu*E,d=h-(h-E),p=E-d,h=hu*f,g=h-(h-f),y=f-g,M=p*y-(w-d*g-p*g-d*y),v=x-M,l=x-v,wu[0]=x-(v+l)+(l-M),_=m+v,l=_-m,b=m-(_-l)+(v-l),v=b-w,l=b-v,wu[1]=b-(v+l)+(l-w),T=_+v,l=T-_,wu[2]=_-(T-l)+(v-l),wu[3]=T;const z=pu(P,bu,4,wu,mu);m=u*s,h=hu*u,d=h-(h-u),p=u-d,h=hu*s,g=h-(h-s),y=s-g,x=p*y-(m-d*g-p*g-d*y),w=c*f,h=hu*c,d=h-(h-c),p=c-d,h=hu*f,g=h-(h-f),y=f-g,M=p*y-(w-d*g-p*g-d*y),v=x-M,l=x-v,wu[0]=x-(v+l)+(l-M),_=m+v,l=_-m,b=m-(_-l)+(v-l),v=b-w,l=b-v,wu[1]=b-(v+l)+(l-w),T=_+v,l=T-_,wu[2]=_-(T-l)+(v-l),wu[3]=T;const $=pu(z,mu,4,wu,xu);return xu[$-1]}(t,n,e,r,i,o,f)}const Tu=Math.pow(2,-52),Au=new Uint32Array(512);class Su{static from(t,n=zu,e=$u){const r=t.length,i=new Float64Array(2*r);for(let o=0;o>1;if(n>0&&"number"!=typeof t[0])throw new Error("Expected coords to contain numbers.");this.coords=t;const e=Math.max(2*n-5,0);this._triangles=new Uint32Array(3*e),this._halfedges=new Int32Array(3*e),this._hashSize=Math.ceil(Math.sqrt(n)),this._hullPrev=new Uint32Array(n),this._hullNext=new Uint32Array(n),this._hullTri=new Uint32Array(n),this._hullHash=new Int32Array(this._hashSize),this._ids=new Uint32Array(n),this._dists=new Float64Array(n),this.update()}update(){const{coords:t,_hullPrev:n,_hullNext:e,_hullTri:r,_hullHash:i}=this,o=t.length>>1;let a=1/0,u=1/0,c=-1/0,f=-1/0;for(let n=0;nc&&(c=e),r>f&&(f=r),this._ids[n]=n}const s=(a+c)/2,l=(u+f)/2;let h,d,p;for(let n=0,e=1/0;n0&&(d=n,e=r)}let v=t[2*d],_=t[2*d+1],b=1/0;for(let n=0;nr&&(n[e++]=i,r=o)}return this.hull=n.subarray(0,e),this.triangles=new Uint32Array(0),void(this.halfedges=new Uint32Array(0))}if(Mu(g,y,v,_,m,x)<0){const t=d,n=v,e=_;d=p,v=m,_=x,p=t,m=n,x=e}const w=function(t,n,e,r,i,o){const a=e-t,u=r-n,c=i-t,f=o-n,s=a*a+u*u,l=c*c+f*f,h=.5/(a*f-u*c),d=t+(f*s-u*l)*h,p=n+(a*l-c*s)*h;return{x:d,y:p}}(g,y,v,_,m,x);this._cx=w.x,this._cy=w.y;for(let n=0;n0&&Math.abs(f-o)<=Tu&&Math.abs(s-a)<=Tu)continue;if(o=f,a=s,c===h||c===d||c===p)continue;let l=0;for(let t=0,n=this._hashKey(f,s);t=0;)if(y=g,y===l){y=-1;break}if(-1===y)continue;let v=this._addTriangle(y,c,e[y],-1,-1,r[y]);r[c]=this._legalize(v+2),r[y]=v,M++;let _=e[y];for(;g=e[_],Mu(f,s,t[2*_],t[2*_+1],t[2*g],t[2*g+1])<0;)v=this._addTriangle(_,c,g,r[c],-1,r[_]),r[c]=this._legalize(v+2),e[_]=_,M--,_=g;if(y===l)for(;g=n[y],Mu(f,s,t[2*g],t[2*g+1],t[2*y],t[2*y+1])<0;)v=this._addTriangle(g,c,y,-1,r[y],r[g]),this._legalize(v+2),r[g]=v,e[y]=y,M--,y=g;this._hullStart=n[c]=y,e[y]=n[_]=c,e[c]=_,i[this._hashKey(f,s)]=c,i[this._hashKey(t[2*y],t[2*y+1])]=y}this.hull=new Uint32Array(M);for(let t=0,n=this._hullStart;t0?3-e:1+e)/4}(t-this._cx,n-this._cy)*this._hashSize)%this._hashSize}_legalize(t){const{_triangles:n,_halfedges:e,coords:r}=this;let i=0,o=0;for(;;){const a=e[t],u=t-t%3;if(o=u+(t+2)%3,-1===a){if(0===i)break;t=Au[--i];continue}const c=a-a%3,f=u+(t+1)%3,s=c+(a+2)%3,l=n[o],h=n[t],d=n[f],p=n[s];if(Nu(r[2*l],r[2*l+1],r[2*h],r[2*h+1],r[2*d],r[2*d+1],r[2*p],r[2*p+1])){n[t]=p,n[a]=l;const r=e[s];if(-1===r){let n=this._hullStart;do{if(this._hullTri[n]===s){this._hullTri[n]=t;break}n=this._hullPrev[n]}while(n!==this._hullStart)}this._link(t,r),this._link(a,e[o]),this._link(o,s);const u=c+(a+1)%3;i=e&&n[t[a]]>o;)t[a+1]=t[a--];t[a+1]=r}else{let i=e+1,o=r;Pu(t,e+r>>1,i),n[t[e]]>n[t[r]]&&Pu(t,e,r),n[t[i]]>n[t[r]]&&Pu(t,i,r),n[t[e]]>n[t[i]]&&Pu(t,e,i);const a=t[i],u=n[a];for(;;){do{i++}while(n[t[i]]u);if(o=o-e?(Cu(t,n,i,r),Cu(t,n,e,o-1)):(Cu(t,n,e,o-1),Cu(t,n,i,r))}}function Pu(t,n,e){const r=t[n];t[n]=t[e],t[e]=r}function zu(t){return t[0]}function $u(t){return t[1]}const Du=1e-6;class Ru{constructor(){this._x0=this._y0=this._x1=this._y1=null,this._=""}moveTo(t,n){this._+=`M${this._x0=this._x1=+t},${this._y0=this._y1=+n}`}closePath(){null!==this._x1&&(this._x1=this._x0,this._y1=this._y0,this._+="Z")}lineTo(t,n){this._+=`L${this._x1=+t},${this._y1=+n}`}arc(t,n,e){const r=(t=+t)+(e=+e),i=n=+n;if(e<0)throw new Error("negative radius");null===this._x1?this._+=`M${r},${i}`:(Math.abs(this._x1-r)>Du||Math.abs(this._y1-i)>Du)&&(this._+="L"+r+","+i),e&&(this._+=`A${e},${e},0,1,1,${t-e},${n}A${e},${e},0,1,1,${this._x1=r},${this._y1=i}`)}rect(t,n,e,r){this._+=`M${this._x0=this._x1=+t},${this._y0=this._y1=+n}h${+e}v${+r}h${-e}Z`}value(){return this._||null}}class Fu{constructor(){this._=[]}moveTo(t,n){this._.push([t,n])}closePath(){this._.push(this._[0].slice())}lineTo(t,n){this._.push([t,n])}value(){return this._.length?this._:null}}class qu{constructor(t,[n,e,r,i]=[0,0,960,500]){if(!((r=+r)>=(n=+n)&&(i=+i)>=(e=+e)))throw new Error("invalid bounds");this.delaunay=t,this._circumcenters=new Float64Array(2*t.points.length),this.vectors=new Float64Array(2*t.points.length),this.xmax=r,this.xmin=n,this.ymax=i,this.ymin=e,this._init()}update(){return this.delaunay.update(),this._init(),this}_init(){const{delaunay:{points:t,hull:n,triangles:e},vectors:r}=this;let i,o;const a=this.circumcenters=this._circumcenters.subarray(0,e.length/3*2);for(let r,u,c=0,f=0,s=e.length;c1;)i-=2;for(let t=2;t0){if(n>=this.ymax)return null;(i=(this.ymax-n)/r)0){if(t>=this.xmax)return null;(i=(this.xmax-t)/e)this.xmax?2:0)|(nthis.ymax?8:0)}_simplify(t){if(t&&t.length>4){for(let n=0;n2&&function(t){const{triangles:n,coords:e}=t;for(let t=0;t1e-10)return!1}return!0}(t)){this.collinear=Int32Array.from({length:n.length/2},((t,n)=>n)).sort(((t,e)=>n[2*t]-n[2*e]||n[2*t+1]-n[2*e+1]));const t=this.collinear[0],e=this.collinear[this.collinear.length-1],r=[n[2*t],n[2*t+1],n[2*e],n[2*e+1]],i=1e-8*Math.hypot(r[3]-r[1],r[2]-r[0]);for(let t=0,e=n.length/2;t0&&(this.triangles=new Int32Array(3).fill(-1),this.halfedges=new Int32Array(3).fill(-1),this.triangles[0]=r[0],o[r[0]]=1,2===r.length&&(o[r[1]]=0,this.triangles[1]=r[1],this.triangles[2]=r[1]))}voronoi(t){return new qu(this,t)}*neighbors(t){const{inedges:n,hull:e,_hullIndex:r,halfedges:i,triangles:o,collinear:a}=this;if(a){const n=a.indexOf(t);return n>0&&(yield a[n-1]),void(n=0&&i!==e&&i!==r;)e=i;return i}_step(t,n,e){const{inedges:r,hull:i,_hullIndex:o,halfedges:a,triangles:u,points:c}=this;if(-1===r[t]||!c.length)return(t+1)%(c.length>>1);let f=t,s=Iu(n-c[2*t],2)+Iu(e-c[2*t+1],2);const l=r[t];let h=l;do{let r=u[h];const l=Iu(n-c[2*r],2)+Iu(e-c[2*r+1],2);if(l9999?"+"+Ku(n,6):Ku(n,4))+"-"+Ku(t.getUTCMonth()+1,2)+"-"+Ku(t.getUTCDate(),2)+(o?"T"+Ku(e,2)+":"+Ku(r,2)+":"+Ku(i,2)+"."+Ku(o,3)+"Z":i?"T"+Ku(e,2)+":"+Ku(r,2)+":"+Ku(i,2)+"Z":r||e?"T"+Ku(e,2)+":"+Ku(r,2)+"Z":"")}function Ju(t){var n=new RegExp('["'+t+"\n\r]"),e=t.charCodeAt(0);function r(t,n){var r,i=[],o=t.length,a=0,u=0,c=o<=0,f=!1;function s(){if(c)return Hu;if(f)return f=!1,ju;var n,r,i=a;if(t.charCodeAt(i)===Xu){for(;a++=o?c=!0:(r=t.charCodeAt(a++))===Gu?f=!0:r===Vu&&(f=!0,t.charCodeAt(a)===Gu&&++a),t.slice(i+1,n-1).replace(/""/g,'"')}for(;amc(n,e).then((n=>(new DOMParser).parseFromString(n,t)))}var Sc=Ac("application/xml"),Ec=Ac("text/html"),Nc=Ac("image/svg+xml");function kc(t,n,e,r){if(isNaN(n)||isNaN(e))return t;var i,o,a,u,c,f,s,l,h,d=t._root,p={data:r},g=t._x0,y=t._y0,v=t._x1,_=t._y1;if(!d)return t._root=p,t;for(;d.length;)if((f=n>=(o=(g+v)/2))?g=o:v=o,(s=e>=(a=(y+_)/2))?y=a:_=a,i=d,!(d=d[l=s<<1|f]))return i[l]=p,t;if(u=+t._x.call(null,d.data),c=+t._y.call(null,d.data),n===u&&e===c)return p.next=d,i?i[l]=p:t._root=p,t;do{i=i?i[l]=new Array(4):t._root=new Array(4),(f=n>=(o=(g+v)/2))?g=o:v=o,(s=e>=(a=(y+_)/2))?y=a:_=a}while((l=s<<1|f)==(h=(c>=a)<<1|u>=o));return i[h]=d,i[l]=p,t}function Cc(t,n,e,r,i){this.node=t,this.x0=n,this.y0=e,this.x1=r,this.y1=i}function Pc(t){return t[0]}function zc(t){return t[1]}function $c(t,n,e){var r=new Dc(null==n?Pc:n,null==e?zc:e,NaN,NaN,NaN,NaN);return null==t?r:r.addAll(t)}function Dc(t,n,e,r,i,o){this._x=t,this._y=n,this._x0=e,this._y0=r,this._x1=i,this._y1=o,this._root=void 0}function Rc(t){for(var n={data:t.data},e=n;t=t.next;)e=e.next={data:t.data};return n}var Fc=$c.prototype=Dc.prototype;function qc(t){return function(){return t}}function Uc(t){return 1e-6*(t()-.5)}function Ic(t){return t.x+t.vx}function Oc(t){return t.y+t.vy}function Bc(t){return t.index}function Yc(t,n){var e=t.get(n);if(!e)throw new Error("node not found: "+n);return e}Fc.copy=function(){var t,n,e=new Dc(this._x,this._y,this._x0,this._y0,this._x1,this._y1),r=this._root;if(!r)return e;if(!r.length)return e._root=Rc(r),e;for(t=[{source:r,target:e._root=new Array(4)}];r=t.pop();)for(var i=0;i<4;++i)(n=r.source[i])&&(n.length?t.push({source:n,target:r.target[i]=new Array(4)}):r.target[i]=Rc(n));return e},Fc.add=function(t){const n=+this._x.call(null,t),e=+this._y.call(null,t);return kc(this.cover(n,e),n,e,t)},Fc.addAll=function(t){var n,e,r,i,o=t.length,a=new Array(o),u=new Array(o),c=1/0,f=1/0,s=-1/0,l=-1/0;for(e=0;es&&(s=r),il&&(l=i));if(c>s||f>l)return this;for(this.cover(c,f).cover(s,l),e=0;et||t>=i||r>n||n>=o;)switch(u=(nh||(o=c.y0)>d||(a=c.x1)=v)<<1|t>=y)&&(c=p[p.length-1],p[p.length-1]=p[p.length-1-f],p[p.length-1-f]=c)}else{var _=t-+this._x.call(null,g.data),b=n-+this._y.call(null,g.data),m=_*_+b*b;if(m=(u=(p+y)/2))?p=u:y=u,(s=a>=(c=(g+v)/2))?g=c:v=c,n=d,!(d=d[l=s<<1|f]))return this;if(!d.length)break;(n[l+1&3]||n[l+2&3]||n[l+3&3])&&(e=n,h=l)}for(;d.data!==t;)if(r=d,!(d=d.next))return this;return(i=d.next)&&delete d.next,r?(i?r.next=i:delete r.next,this):n?(i?n[l]=i:delete n[l],(d=n[0]||n[1]||n[2]||n[3])&&d===(n[3]||n[2]||n[1]||n[0])&&!d.length&&(e?e[h]=d:this._root=d),this):(this._root=i,this)},Fc.removeAll=function(t){for(var n=0,e=t.length;n1?r[0]+r.slice(2):r,+t.slice(e+1)]}function Zc(t){return(t=Wc(Math.abs(t)))?t[1]:NaN}var Kc,Qc=/^(?:(.)?([<>=^]))?([+\-( ])?([$#])?(0)?(\d+)?(,)?(\.\d+)?(~)?([a-z%])?$/i;function Jc(t){if(!(n=Qc.exec(t)))throw new Error("invalid format: "+t);var n;return new tf({fill:n[1],align:n[2],sign:n[3],symbol:n[4],zero:n[5],width:n[6],comma:n[7],precision:n[8]&&n[8].slice(1),trim:n[9],type:n[10]})}function tf(t){this.fill=void 0===t.fill?" ":t.fill+"",this.align=void 0===t.align?">":t.align+"",this.sign=void 0===t.sign?"-":t.sign+"",this.symbol=void 0===t.symbol?"":t.symbol+"",this.zero=!!t.zero,this.width=void 0===t.width?void 0:+t.width,this.comma=!!t.comma,this.precision=void 0===t.precision?void 0:+t.precision,this.trim=!!t.trim,this.type=void 0===t.type?"":t.type+""}function nf(t,n){var e=Wc(t,n);if(!e)return t+"";var r=e[0],i=e[1];return i<0?"0."+new Array(-i).join("0")+r:r.length>i+1?r.slice(0,i+1)+"."+r.slice(i+1):r+new Array(i-r.length+2).join("0")}Jc.prototype=tf.prototype,tf.prototype.toString=function(){return this.fill+this.align+this.sign+this.symbol+(this.zero?"0":"")+(void 0===this.width?"":Math.max(1,0|this.width))+(this.comma?",":"")+(void 0===this.precision?"":"."+Math.max(0,0|this.precision))+(this.trim?"~":"")+this.type};var ef={"%":(t,n)=>(100*t).toFixed(n),b:t=>Math.round(t).toString(2),c:t=>t+"",d:function(t){return Math.abs(t=Math.round(t))>=1e21?t.toLocaleString("en").replace(/,/g,""):t.toString(10)},e:(t,n)=>t.toExponential(n),f:(t,n)=>t.toFixed(n),g:(t,n)=>t.toPrecision(n),o:t=>Math.round(t).toString(8),p:(t,n)=>nf(100*t,n),r:nf,s:function(t,n){var e=Wc(t,n);if(!e)return t+"";var r=e[0],i=e[1],o=i-(Kc=3*Math.max(-8,Math.min(8,Math.floor(i/3))))+1,a=r.length;return o===a?r:o>a?r+new Array(o-a+1).join("0"):o>0?r.slice(0,o)+"."+r.slice(o):"0."+new Array(1-o).join("0")+Wc(t,Math.max(0,n+o-1))[0]},X:t=>Math.round(t).toString(16).toUpperCase(),x:t=>Math.round(t).toString(16)};function rf(t){return t}var of,af=Array.prototype.map,uf=["y","z","a","f","p","n","µ","m","","k","M","G","T","P","E","Z","Y"];function cf(t){var n,e,r=void 0===t.grouping||void 0===t.thousands?rf:(n=af.call(t.grouping,Number),e=t.thousands+"",function(t,r){for(var i=t.length,o=[],a=0,u=n[0],c=0;i>0&&u>0&&(c+u+1>r&&(u=Math.max(1,r-c)),o.push(t.substring(i-=u,i+u)),!((c+=u+1)>r));)u=n[a=(a+1)%n.length];return o.reverse().join(e)}),i=void 0===t.currency?"":t.currency[0]+"",o=void 0===t.currency?"":t.currency[1]+"",a=void 0===t.decimal?".":t.decimal+"",u=void 0===t.numerals?rf:function(t){return function(n){return n.replace(/[0-9]/g,(function(n){return t[+n]}))}}(af.call(t.numerals,String)),c=void 0===t.percent?"%":t.percent+"",f=void 0===t.minus?"−":t.minus+"",s=void 0===t.nan?"NaN":t.nan+"";function l(t){var n=(t=Jc(t)).fill,e=t.align,l=t.sign,h=t.symbol,d=t.zero,p=t.width,g=t.comma,y=t.precision,v=t.trim,_=t.type;"n"===_?(g=!0,_="g"):ef[_]||(void 0===y&&(y=12),v=!0,_="g"),(d||"0"===n&&"="===e)&&(d=!0,n="0",e="=");var b="$"===h?i:"#"===h&&/[boxX]/.test(_)?"0"+_.toLowerCase():"",m="$"===h?o:/[%p]/.test(_)?c:"",x=ef[_],w=/[defgprs%]/.test(_);function M(t){var i,o,c,h=b,M=m;if("c"===_)M=x(t)+M,t="";else{var T=(t=+t)<0||1/t<0;if(t=isNaN(t)?s:x(Math.abs(t),y),v&&(t=function(t){t:for(var n,e=t.length,r=1,i=-1;r0&&(i=0)}return i>0?t.slice(0,i)+t.slice(n+1):t}(t)),T&&0==+t&&"+"!==l&&(T=!1),h=(T?"("===l?l:f:"-"===l||"("===l?"":l)+h,M=("s"===_?uf[8+Kc/3]:"")+M+(T&&"("===l?")":""),w)for(i=-1,o=t.length;++i(c=t.charCodeAt(i))||c>57){M=(46===c?a+t.slice(i+1):t.slice(i))+M,t=t.slice(0,i);break}}g&&!d&&(t=r(t,1/0));var A=h.length+t.length+M.length,S=A>1)+h+t+M+S.slice(A);break;default:t=S+h+t+M}return u(t)}return y=void 0===y?6:/[gprs]/.test(_)?Math.max(1,Math.min(21,y)):Math.max(0,Math.min(20,y)),M.toString=function(){return t+""},M}return{format:l,formatPrefix:function(t,n){var e=l(((t=Jc(t)).type="f",t)),r=3*Math.max(-8,Math.min(8,Math.floor(Zc(n)/3))),i=Math.pow(10,-r),o=uf[8+r/3];return function(t){return e(i*t)+o}}}}function ff(n){return of=cf(n),t.format=of.format,t.formatPrefix=of.formatPrefix,of}function sf(t){return Math.max(0,-Zc(Math.abs(t)))}function lf(t,n){return Math.max(0,3*Math.max(-8,Math.min(8,Math.floor(Zc(n)/3)))-Zc(Math.abs(t)))}function hf(t,n){return t=Math.abs(t),n=Math.abs(n)-t,Math.max(0,Zc(n)-Zc(t))+1}t.format=void 0,t.formatPrefix=void 0,ff({thousands:",",grouping:[3],currency:["$",""]});var df=1e-6,pf=1e-12,gf=Math.PI,yf=gf/2,vf=gf/4,_f=2*gf,bf=180/gf,mf=gf/180,xf=Math.abs,wf=Math.atan,Mf=Math.atan2,Tf=Math.cos,Af=Math.ceil,Sf=Math.exp,Ef=Math.hypot,Nf=Math.log,kf=Math.pow,Cf=Math.sin,Pf=Math.sign||function(t){return t>0?1:t<0?-1:0},zf=Math.sqrt,$f=Math.tan;function Df(t){return t>1?0:t<-1?gf:Math.acos(t)}function Rf(t){return t>1?yf:t<-1?-yf:Math.asin(t)}function Ff(t){return(t=Cf(t/2))*t}function qf(){}function Uf(t,n){t&&Of.hasOwnProperty(t.type)&&Of[t.type](t,n)}var If={Feature:function(t,n){Uf(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r=0?1:-1,i=r*e,o=Tf(n=(n*=mf)/2+vf),a=Cf(n),u=Vf*a,c=Gf*o+u*Tf(i),f=u*r*Cf(i);as.add(Mf(f,c)),Xf=t,Gf=o,Vf=a}function ds(t){return[Mf(t[1],t[0]),Rf(t[2])]}function ps(t){var n=t[0],e=t[1],r=Tf(e);return[r*Tf(n),r*Cf(n),Cf(e)]}function gs(t,n){return t[0]*n[0]+t[1]*n[1]+t[2]*n[2]}function ys(t,n){return[t[1]*n[2]-t[2]*n[1],t[2]*n[0]-t[0]*n[2],t[0]*n[1]-t[1]*n[0]]}function vs(t,n){t[0]+=n[0],t[1]+=n[1],t[2]+=n[2]}function _s(t,n){return[t[0]*n,t[1]*n,t[2]*n]}function bs(t){var n=zf(t[0]*t[0]+t[1]*t[1]+t[2]*t[2]);t[0]/=n,t[1]/=n,t[2]/=n}var ms,xs,ws,Ms,Ts,As,Ss,Es,Ns,ks,Cs,Ps,zs,$s,Ds,Rs,Fs={point:qs,lineStart:Is,lineEnd:Os,polygonStart:function(){Fs.point=Bs,Fs.lineStart=Ys,Fs.lineEnd=Ls,rs=new T,cs.polygonStart()},polygonEnd:function(){cs.polygonEnd(),Fs.point=qs,Fs.lineStart=Is,Fs.lineEnd=Os,as<0?(Wf=-(Kf=180),Zf=-(Qf=90)):rs>df?Qf=90:rs<-df&&(Zf=-90),os[0]=Wf,os[1]=Kf},sphere:function(){Wf=-(Kf=180),Zf=-(Qf=90)}};function qs(t,n){is.push(os=[Wf=t,Kf=t]),nQf&&(Qf=n)}function Us(t,n){var e=ps([t*mf,n*mf]);if(es){var r=ys(es,e),i=ys([r[1],-r[0],0],r);bs(i),i=ds(i);var o,a=t-Jf,u=a>0?1:-1,c=i[0]*bf*u,f=xf(a)>180;f^(u*JfQf&&(Qf=o):f^(u*Jf<(c=(c+360)%360-180)&&cQf&&(Qf=n)),f?tjs(Wf,Kf)&&(Kf=t):js(t,Kf)>js(Wf,Kf)&&(Wf=t):Kf>=Wf?(tKf&&(Kf=t)):t>Jf?js(Wf,t)>js(Wf,Kf)&&(Kf=t):js(t,Kf)>js(Wf,Kf)&&(Wf=t)}else is.push(os=[Wf=t,Kf=t]);nQf&&(Qf=n),es=e,Jf=t}function Is(){Fs.point=Us}function Os(){os[0]=Wf,os[1]=Kf,Fs.point=qs,es=null}function Bs(t,n){if(es){var e=t-Jf;rs.add(xf(e)>180?e+(e>0?360:-360):e)}else ts=t,ns=n;cs.point(t,n),Us(t,n)}function Ys(){cs.lineStart()}function Ls(){Bs(ts,ns),cs.lineEnd(),xf(rs)>df&&(Wf=-(Kf=180)),os[0]=Wf,os[1]=Kf,es=null}function js(t,n){return(n-=t)<0?n+360:n}function Hs(t,n){return t[0]-n[0]}function Xs(t,n){return t[0]<=t[1]?t[0]<=n&&n<=t[1]:ngf&&(t-=Math.round(t/_f)*_f),[t,n]}function ul(t,n,e){return(t%=_f)?n||e?ol(fl(t),sl(n,e)):fl(t):n||e?sl(n,e):al}function cl(t){return function(n,e){return xf(n+=t)>gf&&(n-=Math.round(n/_f)*_f),[n,e]}}function fl(t){var n=cl(t);return n.invert=cl(-t),n}function sl(t,n){var e=Tf(t),r=Cf(t),i=Tf(n),o=Cf(n);function a(t,n){var a=Tf(n),u=Tf(t)*a,c=Cf(t)*a,f=Cf(n),s=f*e+u*r;return[Mf(c*i-s*o,u*e-f*r),Rf(s*i+c*o)]}return a.invert=function(t,n){var a=Tf(n),u=Tf(t)*a,c=Cf(t)*a,f=Cf(n),s=f*i-c*o;return[Mf(c*i+f*o,u*e+s*r),Rf(s*e-u*r)]},a}function ll(t){function n(n){return(n=t(n[0]*mf,n[1]*mf))[0]*=bf,n[1]*=bf,n}return t=ul(t[0]*mf,t[1]*mf,t.length>2?t[2]*mf:0),n.invert=function(n){return(n=t.invert(n[0]*mf,n[1]*mf))[0]*=bf,n[1]*=bf,n},n}function hl(t,n,e,r,i,o){if(e){var a=Tf(n),u=Cf(n),c=r*e;null==i?(i=n+r*_f,o=n-c/2):(i=dl(a,i),o=dl(a,o),(r>0?io)&&(i+=r*_f));for(var f,s=i;r>0?s>o:s1&&n.push(n.pop().concat(n.shift()))},result:function(){var e=n;return n=[],t=null,e}}}function gl(t,n){return xf(t[0]-n[0])=0;--o)i.point((s=f[o])[0],s[1]);else r(h.x,h.p.x,-1,i);h=h.p}f=(h=h.o).z,d=!d}while(!h.v);i.lineEnd()}}}function _l(t){if(n=t.length){for(var n,e,r=0,i=t[0];++r=0?1:-1,E=S*A,N=E>gf,k=y*w;if(c.add(Mf(k*S*Cf(E),v*M+k*Tf(E))),a+=N?A+S*_f:A,N^p>=e^m>=e){var C=ys(ps(d),ps(b));bs(C);var P=ys(o,C);bs(P);var z=(N^A>=0?-1:1)*Rf(P[2]);(r>z||r===z&&(C[0]||C[1]))&&(u+=N^A>=0?1:-1)}}return(a<-df||a0){for(l||(i.polygonStart(),l=!0),i.lineStart(),t=0;t1&&2&c&&h.push(h.pop().concat(h.shift())),a.push(h.filter(wl))}return h}}function wl(t){return t.length>1}function Ml(t,n){return((t=t.x)[0]<0?t[1]-yf-df:yf-t[1])-((n=n.x)[0]<0?n[1]-yf-df:yf-n[1])}al.invert=al;var Tl=xl((function(){return!0}),(function(t){var n,e=NaN,r=NaN,i=NaN;return{lineStart:function(){t.lineStart(),n=1},point:function(o,a){var u=o>0?gf:-gf,c=xf(o-e);xf(c-gf)0?yf:-yf),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(u,r),t.point(o,r),n=0):i!==u&&c>=gf&&(xf(e-i)df?wf((Cf(n)*(o=Tf(r))*Cf(e)-Cf(r)*(i=Tf(n))*Cf(t))/(i*o*a)):(n+r)/2}(e,r,o,a),t.point(i,r),t.lineEnd(),t.lineStart(),t.point(u,r),n=0),t.point(e=o,r=a),i=u},lineEnd:function(){t.lineEnd(),e=r=NaN},clean:function(){return 2-n}}}),(function(t,n,e,r){var i;if(null==t)i=e*yf,r.point(-gf,i),r.point(0,i),r.point(gf,i),r.point(gf,0),r.point(gf,-i),r.point(0,-i),r.point(-gf,-i),r.point(-gf,0),r.point(-gf,i);else if(xf(t[0]-n[0])>df){var o=t[0]0,i=xf(n)>df;function o(t,e){return Tf(t)*Tf(e)>n}function a(t,e,r){var i=[1,0,0],o=ys(ps(t),ps(e)),a=gs(o,o),u=o[0],c=a-u*u;if(!c)return!r&&t;var f=n*a/c,s=-n*u/c,l=ys(i,o),h=_s(i,f);vs(h,_s(o,s));var d=l,p=gs(h,d),g=gs(d,d),y=p*p-g*(gs(h,h)-1);if(!(y<0)){var v=zf(y),_=_s(d,(-p-v)/g);if(vs(_,h),_=ds(_),!r)return _;var b,m=t[0],x=e[0],w=t[1],M=e[1];x0^_[1]<(xf(_[0]-m)gf^(m<=_[0]&&_[0]<=x)){var S=_s(d,(-p+v)/g);return vs(S,h),[_,ds(S)]}}}function u(n,e){var i=r?t:gf-t,o=0;return n<-i?o|=1:n>i&&(o|=2),e<-i?o|=4:e>i&&(o|=8),o}return xl(o,(function(t){var n,e,c,f,s;return{lineStart:function(){f=c=!1,s=1},point:function(l,h){var d,p=[l,h],g=o(l,h),y=r?g?0:u(l,h):g?u(l+(l<0?gf:-gf),h):0;if(!n&&(f=c=g)&&t.lineStart(),g!==c&&(!(d=a(n,p))||gl(n,d)||gl(p,d))&&(p[2]=1),g!==c)s=0,g?(t.lineStart(),d=a(p,n),t.point(d[0],d[1])):(d=a(n,p),t.point(d[0],d[1],2),t.lineEnd()),n=d;else if(i&&n&&r^g){var v;y&e||!(v=a(p,n,!0))||(s=0,r?(t.lineStart(),t.point(v[0][0],v[0][1]),t.point(v[1][0],v[1][1]),t.lineEnd()):(t.point(v[1][0],v[1][1]),t.lineEnd(),t.lineStart(),t.point(v[0][0],v[0][1],3)))}!g||n&&gl(n,p)||t.point(p[0],p[1]),n=p,c=g,e=y},lineEnd:function(){c&&t.lineEnd(),n=null},clean:function(){return s|(f&&c)<<1}}}),(function(n,r,i,o){hl(o,t,e,i,n,r)}),r?[0,-t]:[-gf,t-gf])}var Sl,El,Nl,kl,Cl=1e9,Pl=-Cl;function zl(t,n,e,r){function i(i,o){return t<=i&&i<=e&&n<=o&&o<=r}function o(i,o,u,f){var s=0,l=0;if(null==i||(s=a(i,u))!==(l=a(o,u))||c(i,o)<0^u>0)do{f.point(0===s||3===s?t:e,s>1?r:n)}while((s=(s+u+4)%4)!==l);else f.point(o[0],o[1])}function a(r,i){return xf(r[0]-t)0?0:3:xf(r[0]-e)0?2:1:xf(r[1]-n)0?1:0:i>0?3:2}function u(t,n){return c(t.x,n.x)}function c(t,n){var e=a(t,1),r=a(n,1);return e!==r?e-r:0===e?n[1]-t[1]:1===e?t[0]-n[0]:2===e?t[1]-n[1]:n[0]-t[0]}return function(a){var c,f,s,l,h,d,p,g,y,v,_,b=a,m=pl(),x={point:w,lineStart:function(){x.point=M,f&&f.push(s=[]);v=!0,y=!1,p=g=NaN},lineEnd:function(){c&&(M(l,h),d&&y&&m.rejoin(),c.push(m.result()));x.point=w,y&&b.lineEnd()},polygonStart:function(){b=m,c=[],f=[],_=!0},polygonEnd:function(){var n=function(){for(var n=0,e=0,i=f.length;er&&(h-o)*(r-a)>(d-a)*(t-o)&&++n:d<=r&&(h-o)*(r-a)<(d-a)*(t-o)&&--n;return n}(),e=_&&n,i=(c=ft(c)).length;(e||i)&&(a.polygonStart(),e&&(a.lineStart(),o(null,null,1,a),a.lineEnd()),i&&vl(c,u,n,o,a),a.polygonEnd());b=a,c=f=s=null}};function w(t,n){i(t,n)&&b.point(t,n)}function M(o,a){var u=i(o,a);if(f&&s.push([o,a]),v)l=o,h=a,d=u,v=!1,u&&(b.lineStart(),b.point(o,a));else if(u&&y)b.point(o,a);else{var c=[p=Math.max(Pl,Math.min(Cl,p)),g=Math.max(Pl,Math.min(Cl,g))],m=[o=Math.max(Pl,Math.min(Cl,o)),a=Math.max(Pl,Math.min(Cl,a))];!function(t,n,e,r,i,o){var a,u=t[0],c=t[1],f=0,s=1,l=n[0]-u,h=n[1]-c;if(a=e-u,l||!(a>0)){if(a/=l,l<0){if(a0){if(a>s)return;a>f&&(f=a)}if(a=i-u,l||!(a<0)){if(a/=l,l<0){if(a>s)return;a>f&&(f=a)}else if(l>0){if(a0)){if(a/=h,h<0){if(a0){if(a>s)return;a>f&&(f=a)}if(a=o-c,h||!(a<0)){if(a/=h,h<0){if(a>s)return;a>f&&(f=a)}else if(h>0){if(a0&&(t[0]=u+f*l,t[1]=c+f*h),s<1&&(n[0]=u+s*l,n[1]=c+s*h),!0}}}}}(c,m,t,n,e,r)?u&&(b.lineStart(),b.point(o,a),_=!1):(y||(b.lineStart(),b.point(c[0],c[1])),b.point(m[0],m[1]),u||b.lineEnd(),_=!1)}p=o,g=a,y=u}return x}}var $l={sphere:qf,point:qf,lineStart:function(){$l.point=Rl,$l.lineEnd=Dl},lineEnd:qf,polygonStart:qf,polygonEnd:qf};function Dl(){$l.point=$l.lineEnd=qf}function Rl(t,n){El=t*=mf,Nl=Cf(n*=mf),kl=Tf(n),$l.point=Fl}function Fl(t,n){t*=mf;var e=Cf(n*=mf),r=Tf(n),i=xf(t-El),o=Tf(i),a=r*Cf(i),u=kl*e-Nl*r*o,c=Nl*e+kl*r*o;Sl.add(Mf(zf(a*a+u*u),c)),El=t,Nl=e,kl=r}function ql(t){return Sl=new T,Lf(t,$l),+Sl}var Ul=[null,null],Il={type:"LineString",coordinates:Ul};function Ol(t,n){return Ul[0]=t,Ul[1]=n,ql(Il)}var Bl={Feature:function(t,n){return Ll(t.geometry,n)},FeatureCollection:function(t,n){for(var e=t.features,r=-1,i=e.length;++r0&&(i=Ol(t[o],t[o-1]))>0&&e<=i&&r<=i&&(e+r-i)*(1-Math.pow((e-r)/i,2))df})).map(c)).concat(lt(Af(o/d)*d,i,d).filter((function(t){return xf(t%g)>df})).map(f))}return v.lines=function(){return _().map((function(t){return{type:"LineString",coordinates:t}}))},v.outline=function(){return{type:"Polygon",coordinates:[s(r).concat(l(a).slice(1),s(e).reverse().slice(1),l(u).reverse().slice(1))]}},v.extent=function(t){return arguments.length?v.extentMajor(t).extentMinor(t):v.extentMinor()},v.extentMajor=function(t){return arguments.length?(r=+t[0][0],e=+t[1][0],u=+t[0][1],a=+t[1][1],r>e&&(t=r,r=e,e=t),u>a&&(t=u,u=a,a=t),v.precision(y)):[[r,u],[e,a]]},v.extentMinor=function(e){return arguments.length?(n=+e[0][0],t=+e[1][0],o=+e[0][1],i=+e[1][1],n>t&&(e=n,n=t,t=e),o>i&&(e=o,o=i,i=e),v.precision(y)):[[n,o],[t,i]]},v.step=function(t){return arguments.length?v.stepMajor(t).stepMinor(t):v.stepMinor()},v.stepMajor=function(t){return arguments.length?(p=+t[0],g=+t[1],v):[p,g]},v.stepMinor=function(t){return arguments.length?(h=+t[0],d=+t[1],v):[h,d]},v.precision=function(h){return arguments.length?(y=+h,c=Wl(o,i,90),f=Zl(n,t,y),s=Wl(u,a,90),l=Zl(r,e,y),v):y},v.extentMajor([[-180,-90+df],[180,90-df]]).extentMinor([[-180,-80-df],[180,80+df]])}var Ql,Jl,th,nh,eh=t=>t,rh=new T,ih=new T,oh={point:qf,lineStart:qf,lineEnd:qf,polygonStart:function(){oh.lineStart=ah,oh.lineEnd=fh},polygonEnd:function(){oh.lineStart=oh.lineEnd=oh.point=qf,rh.add(xf(ih)),ih=new T},result:function(){var t=rh/2;return rh=new T,t}};function ah(){oh.point=uh}function uh(t,n){oh.point=ch,Ql=th=t,Jl=nh=n}function ch(t,n){ih.add(nh*t-th*n),th=t,nh=n}function fh(){ch(Ql,Jl)}var sh=oh,lh=1/0,hh=lh,dh=-lh,ph=dh,gh={point:function(t,n){tdh&&(dh=t);nph&&(ph=n)},lineStart:qf,lineEnd:qf,polygonStart:qf,polygonEnd:qf,result:function(){var t=[[lh,hh],[dh,ph]];return dh=ph=-(hh=lh=1/0),t}};var yh,vh,_h,bh,mh=gh,xh=0,wh=0,Mh=0,Th=0,Ah=0,Sh=0,Eh=0,Nh=0,kh=0,Ch={point:Ph,lineStart:zh,lineEnd:Rh,polygonStart:function(){Ch.lineStart=Fh,Ch.lineEnd=qh},polygonEnd:function(){Ch.point=Ph,Ch.lineStart=zh,Ch.lineEnd=Rh},result:function(){var t=kh?[Eh/kh,Nh/kh]:Sh?[Th/Sh,Ah/Sh]:Mh?[xh/Mh,wh/Mh]:[NaN,NaN];return xh=wh=Mh=Th=Ah=Sh=Eh=Nh=kh=0,t}};function Ph(t,n){xh+=t,wh+=n,++Mh}function zh(){Ch.point=$h}function $h(t,n){Ch.point=Dh,Ph(_h=t,bh=n)}function Dh(t,n){var e=t-_h,r=n-bh,i=zf(e*e+r*r);Th+=i*(_h+t)/2,Ah+=i*(bh+n)/2,Sh+=i,Ph(_h=t,bh=n)}function Rh(){Ch.point=Ph}function Fh(){Ch.point=Uh}function qh(){Ih(yh,vh)}function Uh(t,n){Ch.point=Ih,Ph(yh=_h=t,vh=bh=n)}function Ih(t,n){var e=t-_h,r=n-bh,i=zf(e*e+r*r);Th+=i*(_h+t)/2,Ah+=i*(bh+n)/2,Sh+=i,Eh+=(i=bh*t-_h*n)*(_h+t),Nh+=i*(bh+n),kh+=3*i,Ph(_h=t,bh=n)}var Oh=Ch;function Bh(t){this._context=t}Bh.prototype={_radius:4.5,pointRadius:function(t){return this._radius=t,this},polygonStart:function(){this._line=0},polygonEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){0===this._line&&this._context.closePath(),this._point=NaN},point:function(t,n){switch(this._point){case 0:this._context.moveTo(t,n),this._point=1;break;case 1:this._context.lineTo(t,n);break;default:this._context.moveTo(t+this._radius,n),this._context.arc(t,n,this._radius,0,_f)}},result:qf};var Yh,Lh,jh,Hh,Xh,Gh=new T,Vh={point:qf,lineStart:function(){Vh.point=Wh},lineEnd:function(){Yh&&Zh(Lh,jh),Vh.point=qf},polygonStart:function(){Yh=!0},polygonEnd:function(){Yh=null},result:function(){var t=+Gh;return Gh=new T,t}};function Wh(t,n){Vh.point=Zh,Lh=Hh=t,jh=Xh=n}function Zh(t,n){Hh-=t,Xh-=n,Gh.add(zf(Hh*Hh+Xh*Xh)),Hh=t,Xh=n}var Kh=Vh;let Qh,Jh,td,nd;class ed{constructor(t){this._append=null==t?rd:function(t){const n=Math.floor(t);if(!(n>=0))throw new RangeError(`invalid digits: ${t}`);if(n>15)return rd;if(n!==Qh){const t=10**n;Qh=n,Jh=function(n){let e=1;this._+=n[0];for(const r=n.length;e4*n&&g--){var m=a+h,x=u+d,w=c+p,M=zf(m*m+x*x+w*w),T=Rf(w/=M),A=xf(xf(w)-1)n||xf((v*k+_*C)/b-.5)>.3||a*h+u*d+c*p2?t[2]%360*mf:0,k()):[y*bf,v*bf,_*bf]},E.angle=function(t){return arguments.length?(b=t%360*mf,k()):b*bf},E.reflectX=function(t){return arguments.length?(m=t?-1:1,k()):m<0},E.reflectY=function(t){return arguments.length?(x=t?-1:1,k()):x<0},E.precision=function(t){return arguments.length?(a=dd(u,S=t*t),C()):zf(S)},E.fitExtent=function(t,n){return ud(E,t,n)},E.fitSize=function(t,n){return cd(E,t,n)},E.fitWidth=function(t,n){return fd(E,t,n)},E.fitHeight=function(t,n){return sd(E,t,n)},function(){return n=t.apply(this,arguments),E.invert=n.invert&&N,k()}}function _d(t){var n=0,e=gf/3,r=vd(t),i=r(n,e);return i.parallels=function(t){return arguments.length?r(n=t[0]*mf,e=t[1]*mf):[n*bf,e*bf]},i}function bd(t,n){var e=Cf(t),r=(e+Cf(n))/2;if(xf(r)0?n<-yf+df&&(n=-yf+df):n>yf-df&&(n=yf-df);var e=i/kf(Nd(n),r);return[e*Cf(r*t),i-e*Tf(r*t)]}return o.invert=function(t,n){var e=i-n,o=Pf(r)*zf(t*t+e*e),a=Mf(t,xf(e))*Pf(e);return e*r<0&&(a-=gf*Pf(t)*Pf(e)),[a/r,2*wf(kf(i/o,1/r))-yf]},o}function Cd(t,n){return[t,n]}function Pd(t,n){var e=Tf(t),r=t===n?Cf(t):(e-Tf(n))/(n-t),i=e/r+t;if(xf(r)=0;)n+=e[r].value;else n=1;t.value=n}function Gd(t,n){t instanceof Map?(t=[void 0,t],void 0===n&&(n=Wd)):void 0===n&&(n=Vd);for(var e,r,i,o,a,u=new Qd(t),c=[u];e=c.pop();)if((i=n(e.data))&&(a=(i=Array.from(i)).length))for(e.children=i,o=a-1;o>=0;--o)c.push(r=i[o]=new Qd(i[o])),r.parent=e,r.depth=e.depth+1;return u.eachBefore(Kd)}function Vd(t){return t.children}function Wd(t){return Array.isArray(t)?t[1]:null}function Zd(t){void 0!==t.data.value&&(t.value=t.data.value),t.data=t.data.data}function Kd(t){var n=0;do{t.height=n}while((t=t.parent)&&t.height<++n)}function Qd(t){this.data=t,this.depth=this.height=0,this.parent=null}function Jd(t){return null==t?null:tp(t)}function tp(t){if("function"!=typeof t)throw new Error;return t}function np(){return 0}function ep(t){return function(){return t}}qd.invert=function(t,n){for(var e,r=n,i=r*r,o=i*i*i,a=0;a<12&&(o=(i=(r-=e=(r*(zd+$d*i+o*(Dd+Rd*i))-n)/(zd+3*$d*i+o*(7*Dd+9*Rd*i)))*r)*i*i,!(xf(e)df&&--i>0);return[t/(.8707+(o=r*r)*(o*(o*o*o*(.003971-.001529*o)-.013791)-.131979)),r]},Od.invert=Md(Rf),Bd.invert=Md((function(t){return 2*wf(t)})),Yd.invert=function(t,n){return[-n,2*wf(Sf(t))-yf]},Qd.prototype=Gd.prototype={constructor:Qd,count:function(){return this.eachAfter(Xd)},each:function(t,n){let e=-1;for(const r of this)t.call(n,r,++e,this);return this},eachAfter:function(t,n){for(var e,r,i,o=this,a=[o],u=[],c=-1;o=a.pop();)if(u.push(o),e=o.children)for(r=0,i=e.length;r=0;--r)o.push(e[r]);return this},find:function(t,n){let e=-1;for(const r of this)if(t.call(n,r,++e,this))return r},sum:function(t){return this.eachAfter((function(n){for(var e=+t(n.data)||0,r=n.children,i=r&&r.length;--i>=0;)e+=r[i].value;n.value=e}))},sort:function(t){return this.eachBefore((function(n){n.children&&n.children.sort(t)}))},path:function(t){for(var n=this,e=function(t,n){if(t===n)return t;var e=t.ancestors(),r=n.ancestors(),i=null;t=e.pop(),n=r.pop();for(;t===n;)i=t,t=e.pop(),n=r.pop();return i}(n,t),r=[n];n!==e;)n=n.parent,r.push(n);for(var i=r.length;t!==e;)r.splice(i,0,t),t=t.parent;return r},ancestors:function(){for(var t=this,n=[t];t=t.parent;)n.push(t);return n},descendants:function(){return Array.from(this)},leaves:function(){var t=[];return this.eachBefore((function(n){n.children||t.push(n)})),t},links:function(){var t=this,n=[];return t.each((function(e){e!==t&&n.push({source:e.parent,target:e})})),n},copy:function(){return Gd(this).eachBefore(Zd)},[Symbol.iterator]:function*(){var t,n,e,r,i=this,o=[i];do{for(t=o.reverse(),o=[];i=t.pop();)if(yield i,n=i.children)for(e=0,r=n.length;e(t=(rp*t+ip)%op)/op}function up(t,n){for(var e,r,i=0,o=(t=function(t,n){let e,r,i=t.length;for(;i;)r=n()*i--|0,e=t[i],t[i]=t[r],t[r]=e;return t}(Array.from(t),n)).length,a=[];i0&&e*e>r*r+i*i}function lp(t,n){for(var e=0;e1e-6?(E+Math.sqrt(E*E-4*S*N))/(2*S):N/E);return{x:r+w+M*k,y:i+T+A*k,r:k}}function gp(t,n,e){var r,i,o,a,u=t.x-n.x,c=t.y-n.y,f=u*u+c*c;f?(i=n.r+e.r,i*=i,a=t.r+e.r,i>(a*=a)?(r=(f+a-i)/(2*f),o=Math.sqrt(Math.max(0,a/f-r*r)),e.x=t.x-r*u-o*c,e.y=t.y-r*c+o*u):(r=(f+i-a)/(2*f),o=Math.sqrt(Math.max(0,i/f-r*r)),e.x=n.x+r*u-o*c,e.y=n.y+r*c+o*u)):(e.x=n.x+e.r,e.y=n.y)}function yp(t,n){var e=t.r+n.r-1e-6,r=n.x-t.x,i=n.y-t.y;return e>0&&e*e>r*r+i*i}function vp(t){var n=t._,e=t.next._,r=n.r+e.r,i=(n.x*e.r+e.x*n.r)/r,o=(n.y*e.r+e.y*n.r)/r;return i*i+o*o}function _p(t){this._=t,this.next=null,this.previous=null}function bp(t,n){if(!(o=(t=function(t){return"object"==typeof t&&"length"in t?t:Array.from(t)}(t)).length))return 0;var e,r,i,o,a,u,c,f,s,l,h;if((e=t[0]).x=0,e.y=0,!(o>1))return e.r;if(r=t[1],e.x=-r.r,r.x=e.r,r.y=0,!(o>2))return e.r+r.r;gp(r,e,i=t[2]),e=new _p(e),r=new _p(r),i=new _p(i),e.next=i.previous=r,r.next=e.previous=i,i.next=r.previous=e;t:for(c=3;c1&&!zp(t,n););return t.slice(0,n)}function zp(t,n){if("/"===t[n]){let e=0;for(;n>0&&"\\"===t[--n];)++e;if(!(1&e))return!0}return!1}function $p(t,n){return t.parent===n.parent?1:2}function Dp(t){var n=t.children;return n?n[0]:t.t}function Rp(t){var n=t.children;return n?n[n.length-1]:t.t}function Fp(t,n,e){var r=e/(n.i-t.i);n.c-=r,n.s+=e,t.c+=r,n.z+=e,n.m+=e}function qp(t,n,e){return t.a.parent===n.parent?t.a:e}function Up(t,n){this._=t,this.parent=null,this.children=null,this.A=null,this.a=this,this.z=0,this.m=0,this.c=0,this.s=0,this.t=null,this.i=n}function Ip(t,n,e,r,i){for(var o,a=t.children,u=-1,c=a.length,f=t.value&&(i-e)/t.value;++uh&&(h=u),y=s*s*g,(d=Math.max(h/y,y/l))>p){s-=u;break}p=d}v.push(a={value:s,dice:c1?n:1)},e}(Op);var Lp=function t(n){function e(t,e,r,i,o){if((a=t._squarify)&&a.ratio===n)for(var a,u,c,f,s,l=-1,h=a.length,d=t.value;++l1?n:1)},e}(Op);function jp(t,n,e){return(n[0]-t[0])*(e[1]-t[1])-(n[1]-t[1])*(e[0]-t[0])}function Hp(t,n){return t[0]-n[0]||t[1]-n[1]}function Xp(t){const n=t.length,e=[0,1];let r,i=2;for(r=2;r1&&jp(t[e[i-2]],t[e[i-1]],t[r])<=0;)--i;e[i++]=r}return e.slice(0,i)}var Gp=Math.random,Vp=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,1===arguments.length?(e=t,t=0):e-=t,function(){return n()*e+t}}return e.source=t,e}(Gp),Wp=function t(n){function e(t,e){return arguments.length<2&&(e=t,t=0),t=Math.floor(t),e=Math.floor(e)-t,function(){return Math.floor(n()*e+t)}}return e.source=t,e}(Gp),Zp=function t(n){function e(t,e){var r,i;return t=null==t?0:+t,e=null==e?1:+e,function(){var o;if(null!=r)o=r,r=null;else do{r=2*n()-1,o=2*n()-1,i=r*r+o*o}while(!i||i>1);return t+e*o*Math.sqrt(-2*Math.log(i)/i)}}return e.source=t,e}(Gp),Kp=function t(n){var e=Zp.source(n);function r(){var t=e.apply(this,arguments);return function(){return Math.exp(t())}}return r.source=t,r}(Gp),Qp=function t(n){function e(t){return(t=+t)<=0?()=>0:function(){for(var e=0,r=t;r>1;--r)e+=n();return e+r*n()}}return e.source=t,e}(Gp),Jp=function t(n){var e=Qp.source(n);function r(t){if(0==(t=+t))return n;var r=e(t);return function(){return r()/t}}return r.source=t,r}(Gp),tg=function t(n){function e(t){return function(){return-Math.log1p(-n())/t}}return e.source=t,e}(Gp),ng=function t(n){function e(t){if((t=+t)<0)throw new RangeError("invalid alpha");return t=1/-t,function(){return Math.pow(1-n(),t)}}return e.source=t,e}(Gp),eg=function t(n){function e(t){if((t=+t)<0||t>1)throw new RangeError("invalid p");return function(){return Math.floor(n()+t)}}return e.source=t,e}(Gp),rg=function t(n){function e(t){if((t=+t)<0||t>1)throw new RangeError("invalid p");return 0===t?()=>1/0:1===t?()=>1:(t=Math.log1p(-t),function(){return 1+Math.floor(Math.log1p(-n())/t)})}return e.source=t,e}(Gp),ig=function t(n){var e=Zp.source(n)();function r(t,r){if((t=+t)<0)throw new RangeError("invalid k");if(0===t)return()=>0;if(r=null==r?1:+r,1===t)return()=>-Math.log1p(-n())*r;var i=(t<1?t+1:t)-1/3,o=1/(3*Math.sqrt(i)),a=t<1?()=>Math.pow(n(),1/t):()=>1;return function(){do{do{var t=e(),u=1+o*t}while(u<=0);u*=u*u;var c=1-n()}while(c>=1-.0331*t*t*t*t&&Math.log(c)>=.5*t*t+i*(1-u+Math.log(u)));return i*u*a()*r}}return r.source=t,r}(Gp),og=function t(n){var e=ig.source(n);function r(t,n){var r=e(t),i=e(n);return function(){var t=r();return 0===t?0:t/(t+i())}}return r.source=t,r}(Gp),ag=function t(n){var e=rg.source(n),r=og.source(n);function i(t,n){return t=+t,(n=+n)>=1?()=>t:n<=0?()=>0:function(){for(var i=0,o=t,a=n;o*a>16&&o*(1-a)>16;){var u=Math.floor((o+1)*a),c=r(u,o-u+1)();c<=a?(i+=u,o-=u,a=(a-c)/(1-c)):(o=u-1,a/=c)}for(var f=a<.5,s=e(f?a:1-a),l=s(),h=0;l<=o;++h)l+=s();return i+(f?h:o-h)}}return i.source=t,i}(Gp),ug=function t(n){function e(t,e,r){var i;return 0==(t=+t)?i=t=>-Math.log(t):(t=1/t,i=n=>Math.pow(n,t)),e=null==e?0:+e,r=null==r?1:+r,function(){return e+r*i(-Math.log1p(-n()))}}return e.source=t,e}(Gp),cg=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,function(){return t+e*Math.tan(Math.PI*n())}}return e.source=t,e}(Gp),fg=function t(n){function e(t,e){return t=null==t?0:+t,e=null==e?1:+e,function(){var r=n();return t+e*Math.log(r/(1-r))}}return e.source=t,e}(Gp),sg=function t(n){var e=ig.source(n),r=ag.source(n);function i(t){return function(){for(var i=0,o=t;o>16;){var a=Math.floor(.875*o),u=e(a)();if(u>o)return i+r(a-1,o/u)();i+=a,o-=u}for(var c=-Math.log1p(-n()),f=0;c<=o;++f)c-=Math.log1p(-n());return i+f}}return i.source=t,i}(Gp);const lg=1/4294967296;function hg(t,n){switch(arguments.length){case 0:break;case 1:this.range(t);break;default:this.range(n).domain(t)}return this}function dg(t,n){switch(arguments.length){case 0:break;case 1:"function"==typeof t?this.interpolator(t):this.range(t);break;default:this.domain(t),"function"==typeof n?this.interpolator(n):this.range(n)}return this}const pg=Symbol("implicit");function gg(){var t=new InternMap,n=[],e=[],r=pg;function i(i){let o=t.get(i);if(void 0===o){if(r!==pg)return r;t.set(i,o=n.push(i)-1)}return e[o%e.length]}return i.domain=function(e){if(!arguments.length)return n.slice();n=[],t=new InternMap;for(const r of e)t.has(r)||t.set(r,n.push(r)-1);return i},i.range=function(t){return arguments.length?(e=Array.from(t),i):e.slice()},i.unknown=function(t){return arguments.length?(r=t,i):r},i.copy=function(){return gg(n,e).unknown(r)},hg.apply(i,arguments),i}function yg(){var t,n,e=gg().unknown(void 0),r=e.domain,i=e.range,o=0,a=1,u=!1,c=0,f=0,s=.5;function l(){var e=r().length,l=an&&(e=t,t=n,n=e),function(e){return Math.max(t,Math.min(n,e))}}(a[0],a[t-1])),r=t>2?Mg:wg,i=o=null,l}function l(n){return null==n||isNaN(n=+n)?e:(i||(i=r(a.map(t),u,c)))(t(f(n)))}return l.invert=function(e){return f(n((o||(o=r(u,a.map(t),Yr)))(e)))},l.domain=function(t){return arguments.length?(a=Array.from(t,_g),s()):a.slice()},l.range=function(t){return arguments.length?(u=Array.from(t),s()):u.slice()},l.rangeRound=function(t){return u=Array.from(t),c=Vr,s()},l.clamp=function(t){return arguments.length?(f=!!t||mg,s()):f!==mg},l.interpolate=function(t){return arguments.length?(c=t,s()):c},l.unknown=function(t){return arguments.length?(e=t,l):e},function(e,r){return t=e,n=r,s()}}function Sg(){return Ag()(mg,mg)}function Eg(n,e,r,i){var o,a=W(n,e,r);switch((i=Jc(null==i?",f":i)).type){case"s":var u=Math.max(Math.abs(n),Math.abs(e));return null!=i.precision||isNaN(o=lf(a,u))||(i.precision=o),t.formatPrefix(i,u);case"":case"e":case"g":case"p":case"r":null!=i.precision||isNaN(o=hf(a,Math.max(Math.abs(n),Math.abs(e))))||(i.precision=o-("e"===i.type));break;case"f":case"%":null!=i.precision||isNaN(o=sf(a))||(i.precision=o-2*("%"===i.type))}return t.format(i)}function Ng(t){var n=t.domain;return t.ticks=function(t){var e=n();return G(e[0],e[e.length-1],null==t?10:t)},t.tickFormat=function(t,e){var r=n();return Eg(r[0],r[r.length-1],null==t?10:t,e)},t.nice=function(e){null==e&&(e=10);var r,i,o=n(),a=0,u=o.length-1,c=o[a],f=o[u],s=10;for(f0;){if((i=V(c,f,e))===r)return o[a]=c,o[u]=f,n(o);if(i>0)c=Math.floor(c/i)*i,f=Math.ceil(f/i)*i;else{if(!(i<0))break;c=Math.ceil(c*i)/i,f=Math.floor(f*i)/i}r=i}return t},t}function kg(t,n){var e,r=0,i=(t=t.slice()).length-1,o=t[r],a=t[i];return a-t(-n,e)}function Fg(n){const e=n(Cg,Pg),r=e.domain;let i,o,a=10;function u(){return i=function(t){return t===Math.E?Math.log:10===t&&Math.log10||2===t&&Math.log2||(t=Math.log(t),n=>Math.log(n)/t)}(a),o=function(t){return 10===t?Dg:t===Math.E?Math.exp:n=>Math.pow(t,n)}(a),r()[0]<0?(i=Rg(i),o=Rg(o),n(zg,$g)):n(Cg,Pg),e}return e.base=function(t){return arguments.length?(a=+t,u()):a},e.domain=function(t){return arguments.length?(r(t),u()):r()},e.ticks=t=>{const n=r();let e=n[0],u=n[n.length-1];const c=u0){for(;l<=h;++l)for(f=1;fu)break;p.push(s)}}else for(;l<=h;++l)for(f=a-1;f>=1;--f)if(s=l>0?f/o(-l):f*o(l),!(su)break;p.push(s)}2*p.length{if(null==n&&(n=10),null==r&&(r=10===a?"s":","),"function"!=typeof r&&(a%1||null!=(r=Jc(r)).precision||(r.trim=!0),r=t.format(r)),n===1/0)return r;const u=Math.max(1,a*n/e.ticks().length);return t=>{let n=t/o(Math.round(i(t)));return n*ar(kg(r(),{floor:t=>o(Math.floor(i(t))),ceil:t=>o(Math.ceil(i(t)))})),e}function qg(t){return function(n){return Math.sign(n)*Math.log1p(Math.abs(n/t))}}function Ug(t){return function(n){return Math.sign(n)*Math.expm1(Math.abs(n))*t}}function Ig(t){var n=1,e=t(qg(n),Ug(n));return e.constant=function(e){return arguments.length?t(qg(n=+e),Ug(n)):n},Ng(e)}function Og(t){return function(n){return n<0?-Math.pow(-n,t):Math.pow(n,t)}}function Bg(t){return t<0?-Math.sqrt(-t):Math.sqrt(t)}function Yg(t){return t<0?-t*t:t*t}function Lg(t){var n=t(mg,mg),e=1;return n.exponent=function(n){return arguments.length?1===(e=+n)?t(mg,mg):.5===e?t(Bg,Yg):t(Og(e),Og(1/e)):e},Ng(n)}function jg(){var t=Lg(Ag());return t.copy=function(){return Tg(t,jg()).exponent(t.exponent())},hg.apply(t,arguments),t}function Hg(t){return Math.sign(t)*t*t}const Xg=new Date,Gg=new Date;function Vg(t,n,e,r){function i(n){return t(n=0===arguments.length?new Date:new Date(+n)),n}return i.floor=n=>(t(n=new Date(+n)),n),i.ceil=e=>(t(e=new Date(e-1)),n(e,1),t(e),e),i.round=t=>{const n=i(t),e=i.ceil(t);return t-n(n(t=new Date(+t),null==e?1:Math.floor(e)),t),i.range=(e,r,o)=>{const a=[];if(e=i.ceil(e),o=null==o?1:Math.floor(o),!(e0))return a;let u;do{a.push(u=new Date(+e)),n(e,o),t(e)}while(uVg((n=>{if(n>=n)for(;t(n),!e(n);)n.setTime(n-1)}),((t,r)=>{if(t>=t)if(r<0)for(;++r<=0;)for(;n(t,-1),!e(t););else for(;--r>=0;)for(;n(t,1),!e(t););})),e&&(i.count=(n,r)=>(Xg.setTime(+n),Gg.setTime(+r),t(Xg),t(Gg),Math.floor(e(Xg,Gg))),i.every=t=>(t=Math.floor(t),isFinite(t)&&t>0?t>1?i.filter(r?n=>r(n)%t==0:n=>i.count(0,n)%t==0):i:null)),i}const Wg=Vg((()=>{}),((t,n)=>{t.setTime(+t+n)}),((t,n)=>n-t));Wg.every=t=>(t=Math.floor(t),isFinite(t)&&t>0?t>1?Vg((n=>{n.setTime(Math.floor(n/t)*t)}),((n,e)=>{n.setTime(+n+e*t)}),((n,e)=>(e-n)/t)):Wg:null);const Zg=Wg.range,Kg=1e3,Qg=6e4,Jg=36e5,ty=864e5,ny=6048e5,ey=2592e6,ry=31536e6,iy=Vg((t=>{t.setTime(t-t.getMilliseconds())}),((t,n)=>{t.setTime(+t+n*Kg)}),((t,n)=>(n-t)/Kg),(t=>t.getUTCSeconds())),oy=iy.range,ay=Vg((t=>{t.setTime(t-t.getMilliseconds()-t.getSeconds()*Kg)}),((t,n)=>{t.setTime(+t+n*Qg)}),((t,n)=>(n-t)/Qg),(t=>t.getMinutes())),uy=ay.range,cy=Vg((t=>{t.setUTCSeconds(0,0)}),((t,n)=>{t.setTime(+t+n*Qg)}),((t,n)=>(n-t)/Qg),(t=>t.getUTCMinutes())),fy=cy.range,sy=Vg((t=>{t.setTime(t-t.getMilliseconds()-t.getSeconds()*Kg-t.getMinutes()*Qg)}),((t,n)=>{t.setTime(+t+n*Jg)}),((t,n)=>(n-t)/Jg),(t=>t.getHours())),ly=sy.range,hy=Vg((t=>{t.setUTCMinutes(0,0,0)}),((t,n)=>{t.setTime(+t+n*Jg)}),((t,n)=>(n-t)/Jg),(t=>t.getUTCHours())),dy=hy.range,py=Vg((t=>t.setHours(0,0,0,0)),((t,n)=>t.setDate(t.getDate()+n)),((t,n)=>(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*Qg)/ty),(t=>t.getDate()-1)),gy=py.range,yy=Vg((t=>{t.setUTCHours(0,0,0,0)}),((t,n)=>{t.setUTCDate(t.getUTCDate()+n)}),((t,n)=>(n-t)/ty),(t=>t.getUTCDate()-1)),vy=yy.range,_y=Vg((t=>{t.setUTCHours(0,0,0,0)}),((t,n)=>{t.setUTCDate(t.getUTCDate()+n)}),((t,n)=>(n-t)/ty),(t=>Math.floor(t/ty))),by=_y.range;function my(t){return Vg((n=>{n.setDate(n.getDate()-(n.getDay()+7-t)%7),n.setHours(0,0,0,0)}),((t,n)=>{t.setDate(t.getDate()+7*n)}),((t,n)=>(n-t-(n.getTimezoneOffset()-t.getTimezoneOffset())*Qg)/ny))}const xy=my(0),wy=my(1),My=my(2),Ty=my(3),Ay=my(4),Sy=my(5),Ey=my(6),Ny=xy.range,ky=wy.range,Cy=My.range,Py=Ty.range,zy=Ay.range,$y=Sy.range,Dy=Ey.range;function Ry(t){return Vg((n=>{n.setUTCDate(n.getUTCDate()-(n.getUTCDay()+7-t)%7),n.setUTCHours(0,0,0,0)}),((t,n)=>{t.setUTCDate(t.getUTCDate()+7*n)}),((t,n)=>(n-t)/ny))}const Fy=Ry(0),qy=Ry(1),Uy=Ry(2),Iy=Ry(3),Oy=Ry(4),By=Ry(5),Yy=Ry(6),Ly=Fy.range,jy=qy.range,Hy=Uy.range,Xy=Iy.range,Gy=Oy.range,Vy=By.range,Wy=Yy.range,Zy=Vg((t=>{t.setDate(1),t.setHours(0,0,0,0)}),((t,n)=>{t.setMonth(t.getMonth()+n)}),((t,n)=>n.getMonth()-t.getMonth()+12*(n.getFullYear()-t.getFullYear())),(t=>t.getMonth())),Ky=Zy.range,Qy=Vg((t=>{t.setUTCDate(1),t.setUTCHours(0,0,0,0)}),((t,n)=>{t.setUTCMonth(t.getUTCMonth()+n)}),((t,n)=>n.getUTCMonth()-t.getUTCMonth()+12*(n.getUTCFullYear()-t.getUTCFullYear())),(t=>t.getUTCMonth())),Jy=Qy.range,tv=Vg((t=>{t.setMonth(0,1),t.setHours(0,0,0,0)}),((t,n)=>{t.setFullYear(t.getFullYear()+n)}),((t,n)=>n.getFullYear()-t.getFullYear()),(t=>t.getFullYear()));tv.every=t=>isFinite(t=Math.floor(t))&&t>0?Vg((n=>{n.setFullYear(Math.floor(n.getFullYear()/t)*t),n.setMonth(0,1),n.setHours(0,0,0,0)}),((n,e)=>{n.setFullYear(n.getFullYear()+e*t)})):null;const nv=tv.range,ev=Vg((t=>{t.setUTCMonth(0,1),t.setUTCHours(0,0,0,0)}),((t,n)=>{t.setUTCFullYear(t.getUTCFullYear()+n)}),((t,n)=>n.getUTCFullYear()-t.getUTCFullYear()),(t=>t.getUTCFullYear()));ev.every=t=>isFinite(t=Math.floor(t))&&t>0?Vg((n=>{n.setUTCFullYear(Math.floor(n.getUTCFullYear()/t)*t),n.setUTCMonth(0,1),n.setUTCHours(0,0,0,0)}),((n,e)=>{n.setUTCFullYear(n.getUTCFullYear()+e*t)})):null;const rv=ev.range;function iv(t,n,e,i,o,a){const u=[[iy,1,Kg],[iy,5,5e3],[iy,15,15e3],[iy,30,3e4],[a,1,Qg],[a,5,3e5],[a,15,9e5],[a,30,18e5],[o,1,Jg],[o,3,108e5],[o,6,216e5],[o,12,432e5],[i,1,ty],[i,2,1728e5],[e,1,ny],[n,1,ey],[n,3,7776e6],[t,1,ry]];function c(n,e,i){const o=Math.abs(e-n)/i,a=r((([,,t])=>t)).right(u,o);if(a===u.length)return t.every(W(n/ry,e/ry,i));if(0===a)return Wg.every(Math.max(W(n,e,i),1));const[c,f]=u[o/u[a-1][2]=12)]},q:function(t){return 1+~~(t.getMonth()/3)},Q:k_,s:C_,S:Zv,u:Kv,U:Qv,V:t_,w:n_,W:e_,x:null,X:null,y:r_,Y:o_,Z:u_,"%":N_},m={a:function(t){return a[t.getUTCDay()]},A:function(t){return o[t.getUTCDay()]},b:function(t){return c[t.getUTCMonth()]},B:function(t){return u[t.getUTCMonth()]},c:null,d:c_,e:c_,f:d_,g:T_,G:S_,H:f_,I:s_,j:l_,L:h_,m:p_,M:g_,p:function(t){return i[+(t.getUTCHours()>=12)]},q:function(t){return 1+~~(t.getUTCMonth()/3)},Q:k_,s:C_,S:y_,u:v_,U:__,V:m_,w:x_,W:w_,x:null,X:null,y:M_,Y:A_,Z:E_,"%":N_},x={a:function(t,n,e){var r=d.exec(n.slice(e));return r?(t.w=p.get(r[0].toLowerCase()),e+r[0].length):-1},A:function(t,n,e){var r=l.exec(n.slice(e));return r?(t.w=h.get(r[0].toLowerCase()),e+r[0].length):-1},b:function(t,n,e){var r=v.exec(n.slice(e));return r?(t.m=_.get(r[0].toLowerCase()),e+r[0].length):-1},B:function(t,n,e){var r=g.exec(n.slice(e));return r?(t.m=y.get(r[0].toLowerCase()),e+r[0].length):-1},c:function(t,e,r){return T(t,n,e,r)},d:zv,e:zv,f:Uv,g:Nv,G:Ev,H:Dv,I:Dv,j:$v,L:qv,m:Pv,M:Rv,p:function(t,n,e){var r=f.exec(n.slice(e));return r?(t.p=s.get(r[0].toLowerCase()),e+r[0].length):-1},q:Cv,Q:Ov,s:Bv,S:Fv,u:Mv,U:Tv,V:Av,w:wv,W:Sv,x:function(t,n,r){return T(t,e,n,r)},X:function(t,n,e){return T(t,r,n,e)},y:Nv,Y:Ev,Z:kv,"%":Iv};function w(t,n){return function(e){var r,i,o,a=[],u=-1,c=0,f=t.length;for(e instanceof Date||(e=new Date(+e));++u53)return null;"w"in o||(o.w=1),"Z"in o?(i=(r=sv(lv(o.y,0,1))).getUTCDay(),r=i>4||0===i?qy.ceil(r):qy(r),r=yy.offset(r,7*(o.V-1)),o.y=r.getUTCFullYear(),o.m=r.getUTCMonth(),o.d=r.getUTCDate()+(o.w+6)%7):(i=(r=fv(lv(o.y,0,1))).getDay(),r=i>4||0===i?wy.ceil(r):wy(r),r=py.offset(r,7*(o.V-1)),o.y=r.getFullYear(),o.m=r.getMonth(),o.d=r.getDate()+(o.w+6)%7)}else("W"in o||"U"in o)&&("w"in o||(o.w="u"in o?o.u%7:"W"in o?1:0),i="Z"in o?sv(lv(o.y,0,1)).getUTCDay():fv(lv(o.y,0,1)).getDay(),o.m=0,o.d="W"in o?(o.w+6)%7+7*o.W-(i+5)%7:o.w+7*o.U-(i+6)%7);return"Z"in o?(o.H+=o.Z/100|0,o.M+=o.Z%100,sv(o)):fv(o)}}function T(t,n,e,r){for(var i,o,a=0,u=n.length,c=e.length;a=c)return-1;if(37===(i=n.charCodeAt(a++))){if(i=n.charAt(a++),!(o=x[i in pv?n.charAt(a++):i])||(r=o(t,e,r))<0)return-1}else if(i!=e.charCodeAt(r++))return-1}return r}return b.x=w(e,b),b.X=w(r,b),b.c=w(n,b),m.x=w(e,m),m.X=w(r,m),m.c=w(n,m),{format:function(t){var n=w(t+="",b);return n.toString=function(){return t},n},parse:function(t){var n=M(t+="",!1);return n.toString=function(){return t},n},utcFormat:function(t){var n=w(t+="",m);return n.toString=function(){return t},n},utcParse:function(t){var n=M(t+="",!0);return n.toString=function(){return t},n}}}var dv,pv={"-":"",_:" ",0:"0"},gv=/^\s*\d+/,yv=/^%/,vv=/[\\^$*+?|[\]().{}]/g;function _v(t,n,e){var r=t<0?"-":"",i=(r?-t:t)+"",o=i.length;return r+(o[t.toLowerCase(),n])))}function wv(t,n,e){var r=gv.exec(n.slice(e,e+1));return r?(t.w=+r[0],e+r[0].length):-1}function Mv(t,n,e){var r=gv.exec(n.slice(e,e+1));return r?(t.u=+r[0],e+r[0].length):-1}function Tv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.U=+r[0],e+r[0].length):-1}function Av(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.V=+r[0],e+r[0].length):-1}function Sv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.W=+r[0],e+r[0].length):-1}function Ev(t,n,e){var r=gv.exec(n.slice(e,e+4));return r?(t.y=+r[0],e+r[0].length):-1}function Nv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.y=+r[0]+(+r[0]>68?1900:2e3),e+r[0].length):-1}function kv(t,n,e){var r=/^(Z)|([+-]\d\d)(?::?(\d\d))?/.exec(n.slice(e,e+6));return r?(t.Z=r[1]?0:-(r[2]+(r[3]||"00")),e+r[0].length):-1}function Cv(t,n,e){var r=gv.exec(n.slice(e,e+1));return r?(t.q=3*r[0]-3,e+r[0].length):-1}function Pv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.m=r[0]-1,e+r[0].length):-1}function zv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.d=+r[0],e+r[0].length):-1}function $v(t,n,e){var r=gv.exec(n.slice(e,e+3));return r?(t.m=0,t.d=+r[0],e+r[0].length):-1}function Dv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.H=+r[0],e+r[0].length):-1}function Rv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.M=+r[0],e+r[0].length):-1}function Fv(t,n,e){var r=gv.exec(n.slice(e,e+2));return r?(t.S=+r[0],e+r[0].length):-1}function qv(t,n,e){var r=gv.exec(n.slice(e,e+3));return r?(t.L=+r[0],e+r[0].length):-1}function Uv(t,n,e){var r=gv.exec(n.slice(e,e+6));return r?(t.L=Math.floor(r[0]/1e3),e+r[0].length):-1}function Iv(t,n,e){var r=yv.exec(n.slice(e,e+1));return r?e+r[0].length:-1}function Ov(t,n,e){var r=gv.exec(n.slice(e));return r?(t.Q=+r[0],e+r[0].length):-1}function Bv(t,n,e){var r=gv.exec(n.slice(e));return r?(t.s=+r[0],e+r[0].length):-1}function Yv(t,n){return _v(t.getDate(),n,2)}function Lv(t,n){return _v(t.getHours(),n,2)}function jv(t,n){return _v(t.getHours()%12||12,n,2)}function Hv(t,n){return _v(1+py.count(tv(t),t),n,3)}function Xv(t,n){return _v(t.getMilliseconds(),n,3)}function Gv(t,n){return Xv(t,n)+"000"}function Vv(t,n){return _v(t.getMonth()+1,n,2)}function Wv(t,n){return _v(t.getMinutes(),n,2)}function Zv(t,n){return _v(t.getSeconds(),n,2)}function Kv(t){var n=t.getDay();return 0===n?7:n}function Qv(t,n){return _v(xy.count(tv(t)-1,t),n,2)}function Jv(t){var n=t.getDay();return n>=4||0===n?Ay(t):Ay.ceil(t)}function t_(t,n){return t=Jv(t),_v(Ay.count(tv(t),t)+(4===tv(t).getDay()),n,2)}function n_(t){return t.getDay()}function e_(t,n){return _v(wy.count(tv(t)-1,t),n,2)}function r_(t,n){return _v(t.getFullYear()%100,n,2)}function i_(t,n){return _v((t=Jv(t)).getFullYear()%100,n,2)}function o_(t,n){return _v(t.getFullYear()%1e4,n,4)}function a_(t,n){var e=t.getDay();return _v((t=e>=4||0===e?Ay(t):Ay.ceil(t)).getFullYear()%1e4,n,4)}function u_(t){var n=t.getTimezoneOffset();return(n>0?"-":(n*=-1,"+"))+_v(n/60|0,"0",2)+_v(n%60,"0",2)}function c_(t,n){return _v(t.getUTCDate(),n,2)}function f_(t,n){return _v(t.getUTCHours(),n,2)}function s_(t,n){return _v(t.getUTCHours()%12||12,n,2)}function l_(t,n){return _v(1+yy.count(ev(t),t),n,3)}function h_(t,n){return _v(t.getUTCMilliseconds(),n,3)}function d_(t,n){return h_(t,n)+"000"}function p_(t,n){return _v(t.getUTCMonth()+1,n,2)}function g_(t,n){return _v(t.getUTCMinutes(),n,2)}function y_(t,n){return _v(t.getUTCSeconds(),n,2)}function v_(t){var n=t.getUTCDay();return 0===n?7:n}function __(t,n){return _v(Fy.count(ev(t)-1,t),n,2)}function b_(t){var n=t.getUTCDay();return n>=4||0===n?Oy(t):Oy.ceil(t)}function m_(t,n){return t=b_(t),_v(Oy.count(ev(t),t)+(4===ev(t).getUTCDay()),n,2)}function x_(t){return t.getUTCDay()}function w_(t,n){return _v(qy.count(ev(t)-1,t),n,2)}function M_(t,n){return _v(t.getUTCFullYear()%100,n,2)}function T_(t,n){return _v((t=b_(t)).getUTCFullYear()%100,n,2)}function A_(t,n){return _v(t.getUTCFullYear()%1e4,n,4)}function S_(t,n){var e=t.getUTCDay();return _v((t=e>=4||0===e?Oy(t):Oy.ceil(t)).getUTCFullYear()%1e4,n,4)}function E_(){return"+0000"}function N_(){return"%"}function k_(t){return+t}function C_(t){return Math.floor(+t/1e3)}function P_(n){return dv=hv(n),t.timeFormat=dv.format,t.timeParse=dv.parse,t.utcFormat=dv.utcFormat,t.utcParse=dv.utcParse,dv}t.timeFormat=void 0,t.timeParse=void 0,t.utcFormat=void 0,t.utcParse=void 0,P_({dateTime:"%x, %X",date:"%-m/%-d/%Y",time:"%-I:%M:%S %p",periods:["AM","PM"],days:["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"],shortDays:["Sun","Mon","Tue","Wed","Thu","Fri","Sat"],months:["January","February","March","April","May","June","July","August","September","October","November","December"],shortMonths:["Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"]});var z_="%Y-%m-%dT%H:%M:%S.%LZ";var $_=Date.prototype.toISOString?function(t){return t.toISOString()}:t.utcFormat(z_),D_=$_;var R_=+new Date("2000-01-01T00:00:00.000Z")?function(t){var n=new Date(t);return isNaN(n)?null:n}:t.utcParse(z_),F_=R_;function q_(t){return new Date(t)}function U_(t){return t instanceof Date?+t:+new Date(+t)}function I_(t,n,e,r,i,o,a,u,c,f){var s=Sg(),l=s.invert,h=s.domain,d=f(".%L"),p=f(":%S"),g=f("%I:%M"),y=f("%I %p"),v=f("%a %d"),_=f("%b %d"),b=f("%B"),m=f("%Y");function x(t){return(c(t)Fr(t[t.length-1]),ib=new Array(3).concat("d8b365f5f5f55ab4ac","a6611adfc27d80cdc1018571","a6611adfc27df5f5f580cdc1018571","8c510ad8b365f6e8c3c7eae55ab4ac01665e","8c510ad8b365f6e8c3f5f5f5c7eae55ab4ac01665e","8c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e","8c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e","5430058c510abf812ddfc27df6e8c3c7eae580cdc135978f01665e003c30","5430058c510abf812ddfc27df6e8c3f5f5f5c7eae580cdc135978f01665e003c30").map(H_),ob=rb(ib),ab=new Array(3).concat("af8dc3f7f7f77fbf7b","7b3294c2a5cfa6dba0008837","7b3294c2a5cff7f7f7a6dba0008837","762a83af8dc3e7d4e8d9f0d37fbf7b1b7837","762a83af8dc3e7d4e8f7f7f7d9f0d37fbf7b1b7837","762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b7837","762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b7837","40004b762a839970abc2a5cfe7d4e8d9f0d3a6dba05aae611b783700441b","40004b762a839970abc2a5cfe7d4e8f7f7f7d9f0d3a6dba05aae611b783700441b").map(H_),ub=rb(ab),cb=new Array(3).concat("e9a3c9f7f7f7a1d76a","d01c8bf1b6dab8e1864dac26","d01c8bf1b6daf7f7f7b8e1864dac26","c51b7de9a3c9fde0efe6f5d0a1d76a4d9221","c51b7de9a3c9fde0eff7f7f7e6f5d0a1d76a4d9221","c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221","c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221","8e0152c51b7dde77aef1b6dafde0efe6f5d0b8e1867fbc414d9221276419","8e0152c51b7dde77aef1b6dafde0eff7f7f7e6f5d0b8e1867fbc414d9221276419").map(H_),fb=rb(cb),sb=new Array(3).concat("998ec3f7f7f7f1a340","5e3c99b2abd2fdb863e66101","5e3c99b2abd2f7f7f7fdb863e66101","542788998ec3d8daebfee0b6f1a340b35806","542788998ec3d8daebf7f7f7fee0b6f1a340b35806","5427888073acb2abd2d8daebfee0b6fdb863e08214b35806","5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b35806","2d004b5427888073acb2abd2d8daebfee0b6fdb863e08214b358067f3b08","2d004b5427888073acb2abd2d8daebf7f7f7fee0b6fdb863e08214b358067f3b08").map(H_),lb=rb(sb),hb=new Array(3).concat("ef8a62f7f7f767a9cf","ca0020f4a58292c5de0571b0","ca0020f4a582f7f7f792c5de0571b0","b2182bef8a62fddbc7d1e5f067a9cf2166ac","b2182bef8a62fddbc7f7f7f7d1e5f067a9cf2166ac","b2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac","b2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac","67001fb2182bd6604df4a582fddbc7d1e5f092c5de4393c32166ac053061","67001fb2182bd6604df4a582fddbc7f7f7f7d1e5f092c5de4393c32166ac053061").map(H_),db=rb(hb),pb=new Array(3).concat("ef8a62ffffff999999","ca0020f4a582bababa404040","ca0020f4a582ffffffbababa404040","b2182bef8a62fddbc7e0e0e09999994d4d4d","b2182bef8a62fddbc7ffffffe0e0e09999994d4d4d","b2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d","b2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d","67001fb2182bd6604df4a582fddbc7e0e0e0bababa8787874d4d4d1a1a1a","67001fb2182bd6604df4a582fddbc7ffffffe0e0e0bababa8787874d4d4d1a1a1a").map(H_),gb=rb(pb),yb=new Array(3).concat("fc8d59ffffbf91bfdb","d7191cfdae61abd9e92c7bb6","d7191cfdae61ffffbfabd9e92c7bb6","d73027fc8d59fee090e0f3f891bfdb4575b4","d73027fc8d59fee090ffffbfe0f3f891bfdb4575b4","d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4","d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4","a50026d73027f46d43fdae61fee090e0f3f8abd9e974add14575b4313695","a50026d73027f46d43fdae61fee090ffffbfe0f3f8abd9e974add14575b4313695").map(H_),vb=rb(yb),_b=new Array(3).concat("fc8d59ffffbf91cf60","d7191cfdae61a6d96a1a9641","d7191cfdae61ffffbfa6d96a1a9641","d73027fc8d59fee08bd9ef8b91cf601a9850","d73027fc8d59fee08bffffbfd9ef8b91cf601a9850","d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850","d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850","a50026d73027f46d43fdae61fee08bd9ef8ba6d96a66bd631a9850006837","a50026d73027f46d43fdae61fee08bffffbfd9ef8ba6d96a66bd631a9850006837").map(H_),bb=rb(_b),mb=new Array(3).concat("fc8d59ffffbf99d594","d7191cfdae61abdda42b83ba","d7191cfdae61ffffbfabdda42b83ba","d53e4ffc8d59fee08be6f59899d5943288bd","d53e4ffc8d59fee08bffffbfe6f59899d5943288bd","d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd","d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd","9e0142d53e4ff46d43fdae61fee08be6f598abdda466c2a53288bd5e4fa2","9e0142d53e4ff46d43fdae61fee08bffffbfe6f598abdda466c2a53288bd5e4fa2").map(H_),xb=rb(mb),wb=new Array(3).concat("e5f5f999d8c92ca25f","edf8fbb2e2e266c2a4238b45","edf8fbb2e2e266c2a42ca25f006d2c","edf8fbccece699d8c966c2a42ca25f006d2c","edf8fbccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45005824","f7fcfde5f5f9ccece699d8c966c2a441ae76238b45006d2c00441b").map(H_),Mb=rb(wb),Tb=new Array(3).concat("e0ecf49ebcda8856a7","edf8fbb3cde38c96c688419d","edf8fbb3cde38c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68856a7810f7c","edf8fbbfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d6e016b","f7fcfde0ecf4bfd3e69ebcda8c96c68c6bb188419d810f7c4d004b").map(H_),Ab=rb(Tb),Sb=new Array(3).concat("e0f3dba8ddb543a2ca","f0f9e8bae4bc7bccc42b8cbe","f0f9e8bae4bc7bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc443a2ca0868ac","f0f9e8ccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe08589e","f7fcf0e0f3dbccebc5a8ddb57bccc44eb3d32b8cbe0868ac084081").map(H_),Eb=rb(Sb),Nb=new Array(3).concat("fee8c8fdbb84e34a33","fef0d9fdcc8afc8d59d7301f","fef0d9fdcc8afc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59e34a33b30000","fef0d9fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301f990000","fff7ecfee8c8fdd49efdbb84fc8d59ef6548d7301fb300007f0000").map(H_),kb=rb(Nb),Cb=new Array(3).concat("ece2f0a6bddb1c9099","f6eff7bdc9e167a9cf02818a","f6eff7bdc9e167a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf1c9099016c59","f6eff7d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016450","fff7fbece2f0d0d1e6a6bddb67a9cf3690c002818a016c59014636").map(H_),Pb=rb(Cb),zb=new Array(3).concat("ece7f2a6bddb2b8cbe","f1eef6bdc9e174a9cf0570b0","f1eef6bdc9e174a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf2b8cbe045a8d","f1eef6d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0034e7b","fff7fbece7f2d0d1e6a6bddb74a9cf3690c00570b0045a8d023858").map(H_),$b=rb(zb),Db=new Array(3).concat("e7e1efc994c7dd1c77","f1eef6d7b5d8df65b0ce1256","f1eef6d7b5d8df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0dd1c77980043","f1eef6d4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125691003f","f7f4f9e7e1efd4b9dac994c7df65b0e7298ace125698004367001f").map(H_),Rb=rb(Db),Fb=new Array(3).concat("fde0ddfa9fb5c51b8a","feebe2fbb4b9f768a1ae017e","feebe2fbb4b9f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1c51b8a7a0177","feebe2fcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a0177","fff7f3fde0ddfcc5c0fa9fb5f768a1dd3497ae017e7a017749006a").map(H_),qb=rb(Fb),Ub=new Array(3).concat("edf8b17fcdbb2c7fb8","ffffcca1dab441b6c4225ea8","ffffcca1dab441b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c42c7fb8253494","ffffccc7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea80c2c84","ffffd9edf8b1c7e9b47fcdbb41b6c41d91c0225ea8253494081d58").map(H_),Ib=rb(Ub),Ob=new Array(3).concat("f7fcb9addd8e31a354","ffffccc2e69978c679238443","ffffccc2e69978c67931a354006837","ffffccd9f0a3addd8e78c67931a354006837","ffffccd9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443005a32","ffffe5f7fcb9d9f0a3addd8e78c67941ab5d238443006837004529").map(H_),Bb=rb(Ob),Yb=new Array(3).concat("fff7bcfec44fd95f0e","ffffd4fed98efe9929cc4c02","ffffd4fed98efe9929d95f0e993404","ffffd4fee391fec44ffe9929d95f0e993404","ffffd4fee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c028c2d04","ffffe5fff7bcfee391fec44ffe9929ec7014cc4c02993404662506").map(H_),Lb=rb(Yb),jb=new Array(3).concat("ffeda0feb24cf03b20","ffffb2fecc5cfd8d3ce31a1c","ffffb2fecc5cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cf03b20bd0026","ffffb2fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cb10026","ffffccffeda0fed976feb24cfd8d3cfc4e2ae31a1cbd0026800026").map(H_),Hb=rb(jb),Xb=new Array(3).concat("deebf79ecae13182bd","eff3ffbdd7e76baed62171b5","eff3ffbdd7e76baed63182bd08519c","eff3ffc6dbef9ecae16baed63182bd08519c","eff3ffc6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b5084594","f7fbffdeebf7c6dbef9ecae16baed64292c62171b508519c08306b").map(H_),Gb=rb(Xb),Vb=new Array(3).concat("e5f5e0a1d99b31a354","edf8e9bae4b374c476238b45","edf8e9bae4b374c47631a354006d2c","edf8e9c7e9c0a1d99b74c47631a354006d2c","edf8e9c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45005a32","f7fcf5e5f5e0c7e9c0a1d99b74c47641ab5d238b45006d2c00441b").map(H_),Wb=rb(Vb),Zb=new Array(3).concat("f0f0f0bdbdbd636363","f7f7f7cccccc969696525252","f7f7f7cccccc969696636363252525","f7f7f7d9d9d9bdbdbd969696636363252525","f7f7f7d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525","fffffff0f0f0d9d9d9bdbdbd969696737373525252252525000000").map(H_),Kb=rb(Zb),Qb=new Array(3).concat("efedf5bcbddc756bb1","f2f0f7cbc9e29e9ac86a51a3","f2f0f7cbc9e29e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8756bb154278f","f2f0f7dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a34a1486","fcfbfdefedf5dadaebbcbddc9e9ac8807dba6a51a354278f3f007d").map(H_),Jb=rb(Qb),tm=new Array(3).concat("fee0d2fc9272de2d26","fee5d9fcae91fb6a4acb181d","fee5d9fcae91fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4ade2d26a50f15","fee5d9fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181d99000d","fff5f0fee0d2fcbba1fc9272fb6a4aef3b2ccb181da50f1567000d").map(H_),nm=rb(tm),em=new Array(3).concat("fee6cefdae6be6550d","feeddefdbe85fd8d3cd94701","feeddefdbe85fd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3ce6550da63603","feeddefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d948018c2d04","fff5ebfee6cefdd0a2fdae6bfd8d3cf16913d94801a636037f2704").map(H_),rm=rb(em);var im=hi(Tr(300,.5,0),Tr(-240,.5,1)),om=hi(Tr(-100,.75,.35),Tr(80,1.5,.8)),am=hi(Tr(260,.75,.35),Tr(80,1.5,.8)),um=Tr();var cm=Fe(),fm=Math.PI/3,sm=2*Math.PI/3;function lm(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}}var hm=lm(H_("44015444025645045745055946075a46085c460a5d460b5e470d60470e6147106347116447136548146748166848176948186a481a6c481b6d481c6e481d6f481f70482071482173482374482475482576482677482878482979472a7a472c7a472d7b472e7c472f7d46307e46327e46337f463480453581453781453882443983443a83443b84433d84433e85423f854240864241864142874144874045884046883f47883f48893e49893e4a893e4c8a3d4d8a3d4e8a3c4f8a3c508b3b518b3b528b3a538b3a548c39558c39568c38588c38598c375a8c375b8d365c8d365d8d355e8d355f8d34608d34618d33628d33638d32648e32658e31668e31678e31688e30698e306a8e2f6b8e2f6c8e2e6d8e2e6e8e2e6f8e2d708e2d718e2c718e2c728e2c738e2b748e2b758e2a768e2a778e2a788e29798e297a8e297b8e287c8e287d8e277e8e277f8e27808e26818e26828e26828e25838e25848e25858e24868e24878e23888e23898e238a8d228b8d228c8d228d8d218e8d218f8d21908d21918c20928c20928c20938c1f948c1f958b1f968b1f978b1f988b1f998a1f9a8a1e9b8a1e9c891e9d891f9e891f9f881fa0881fa1881fa1871fa28720a38620a48621a58521a68522a78522a88423a98324aa8325ab8225ac8226ad8127ad8128ae8029af7f2ab07f2cb17e2db27d2eb37c2fb47c31b57b32b67a34b67935b77937b87838b9773aba763bbb753dbc743fbc7340bd7242be7144bf7046c06f48c16e4ac16d4cc26c4ec36b50c46a52c56954c56856c66758c7655ac8645cc8635ec96260ca6063cb5f65cb5e67cc5c69cd5b6ccd5a6ece5870cf5773d05675d05477d1537ad1517cd2507fd34e81d34d84d44b86d54989d5488bd6468ed64590d74393d74195d84098d83e9bd93c9dd93ba0da39a2da37a5db36a8db34aadc32addc30b0dd2fb2dd2db5de2bb8de29bade28bddf26c0df25c2df23c5e021c8e020cae11fcde11dd0e11cd2e21bd5e21ad8e219dae319dde318dfe318e2e418e5e419e7e419eae51aece51befe51cf1e51df4e61ef6e620f8e621fbe723fde725")),dm=lm(H_("00000401000501010601010802010902020b02020d03030f03031204041405041606051806051a07061c08071e0907200a08220b09240c09260d0a290e0b2b100b2d110c2f120d31130d34140e36150e38160f3b180f3d19103f1a10421c10441d11471e114920114b21114e22115024125325125527125829115a2a115c2c115f2d11612f116331116533106734106936106b38106c390f6e3b0f703d0f713f0f72400f74420f75440f764510774710784910784a10794c117a4e117b4f127b51127c52137c54137d56147d57157e59157e5a167e5c167f5d177f5f187f601880621980641a80651a80671b80681c816a1c816b1d816d1d816e1e81701f81721f817320817521817621817822817922827b23827c23827e24828025828125818326818426818627818827818928818b29818c29818e2a81902a81912b81932b80942c80962c80982d80992d809b2e7f9c2e7f9e2f7fa02f7fa1307ea3307ea5317ea6317da8327daa337dab337cad347cae347bb0357bb2357bb3367ab5367ab73779b83779ba3878bc3978bd3977bf3a77c03a76c23b75c43c75c53c74c73d73c83e73ca3e72cc3f71cd4071cf4070d0416fd2426fd3436ed5446dd6456cd8456cd9466bdb476adc4869de4968df4a68e04c67e24d66e34e65e44f64e55064e75263e85362e95462ea5661eb5760ec5860ed5a5fee5b5eef5d5ef05f5ef1605df2625df2645cf3655cf4675cf4695cf56b5cf66c5cf66e5cf7705cf7725cf8745cf8765cf9785df9795df97b5dfa7d5efa7f5efa815ffb835ffb8560fb8761fc8961fc8a62fc8c63fc8e64fc9065fd9266fd9467fd9668fd9869fd9a6afd9b6bfe9d6cfe9f6dfea16efea36ffea571fea772fea973feaa74feac76feae77feb078feb27afeb47bfeb67cfeb77efeb97ffebb81febd82febf84fec185fec287fec488fec68afec88cfeca8dfecc8ffecd90fecf92fed194fed395fed597fed799fed89afdda9cfddc9efddea0fde0a1fde2a3fde3a5fde5a7fde7a9fde9aafdebacfcecaefceeb0fcf0b2fcf2b4fcf4b6fcf6b8fcf7b9fcf9bbfcfbbdfcfdbf")),pm=lm(H_("00000401000501010601010802010a02020c02020e03021004031204031405041706041907051b08051d09061f0a07220b07240c08260d08290e092b10092d110a30120a32140b34150b37160b39180c3c190c3e1b0c411c0c431e0c451f0c48210c4a230c4c240c4f260c51280b53290b552b0b572d0b592f0a5b310a5c320a5e340a5f3609613809623909633b09643d09653e0966400a67420a68440a68450a69470b6a490b6a4a0c6b4c0c6b4d0d6c4f0d6c510e6c520e6d540f6d550f6d57106e59106e5a116e5c126e5d126e5f136e61136e62146e64156e65156e67166e69166e6a176e6c186e6d186e6f196e71196e721a6e741a6e751b6e771c6d781c6d7a1d6d7c1d6d7d1e6d7f1e6c801f6c82206c84206b85216b87216b88226a8a226a8c23698d23698f24699025689225689326679526679727669827669a28659b29649d29649f2a63a02a63a22b62a32c61a52c60a62d60a82e5fa92e5eab2f5ead305dae305cb0315bb1325ab3325ab43359b63458b73557b93556ba3655bc3754bd3853bf3952c03a51c13a50c33b4fc43c4ec63d4dc73e4cc83f4bca404acb4149cc4248ce4347cf4446d04545d24644d34743d44842d54a41d74b3fd84c3ed94d3dda4e3cdb503bdd513ade5238df5337e05536e15635e25734e35933e45a31e55c30e65d2fe75e2ee8602de9612bea632aeb6429eb6628ec6726ed6925ee6a24ef6c23ef6e21f06f20f1711ff1731df2741cf3761bf37819f47918f57b17f57d15f67e14f68013f78212f78410f8850ff8870ef8890cf98b0bf98c0af98e09fa9008fa9207fa9407fb9606fb9706fb9906fb9b06fb9d07fc9f07fca108fca309fca50afca60cfca80dfcaa0ffcac11fcae12fcb014fcb216fcb418fbb61afbb81dfbba1ffbbc21fbbe23fac026fac228fac42afac62df9c72ff9c932f9cb35f8cd37f8cf3af7d13df7d340f6d543f6d746f5d949f5db4cf4dd4ff4df53f4e156f3e35af3e55df2e661f2e865f2ea69f1ec6df1ed71f1ef75f1f179f2f27df2f482f3f586f3f68af4f88ef5f992f6fa96f8fb9af9fc9dfafda1fcffa4")),gm=lm(H_("0d088710078813078916078a19068c1b068d1d068e20068f2206902406912605912805922a05932c05942e05952f059631059733059735049837049938049a3a049a3c049b3e049c3f049c41049d43039e44039e46039f48039f4903a04b03a14c02a14e02a25002a25102a35302a35502a45601a45801a45901a55b01a55c01a65e01a66001a66100a76300a76400a76600a76700a86900a86a00a86c00a86e00a86f00a87100a87201a87401a87501a87701a87801a87a02a87b02a87d03a87e03a88004a88104a78305a78405a78606a68707a68808a68a09a58b0aa58d0ba58e0ca48f0da4910ea3920fa39410a29511a19613a19814a099159f9a169f9c179e9d189d9e199da01a9ca11b9ba21d9aa31e9aa51f99a62098a72197a82296aa2395ab2494ac2694ad2793ae2892b02991b12a90b22b8fb32c8eb42e8db52f8cb6308bb7318ab83289ba3388bb3488bc3587bd3786be3885bf3984c03a83c13b82c23c81c33d80c43e7fc5407ec6417dc7427cc8437bc9447aca457acb4679cc4778cc4977cd4a76ce4b75cf4c74d04d73d14e72d24f71d35171d45270d5536fd5546ed6556dd7566cd8576bd9586ada5a6ada5b69db5c68dc5d67dd5e66de5f65de6164df6263e06363e16462e26561e26660e3685fe4695ee56a5de56b5de66c5ce76e5be76f5ae87059e97158e97257ea7457eb7556eb7655ec7754ed7953ed7a52ee7b51ef7c51ef7e50f07f4ff0804ef1814df1834cf2844bf3854bf3874af48849f48948f58b47f58c46f68d45f68f44f79044f79143f79342f89441f89540f9973ff9983ef99a3efa9b3dfa9c3cfa9e3bfb9f3afba139fba238fca338fca537fca636fca835fca934fdab33fdac33fdae32fdaf31fdb130fdb22ffdb42ffdb52efeb72dfeb82cfeba2cfebb2bfebd2afebe2afec029fdc229fdc328fdc527fdc627fdc827fdca26fdcb26fccd25fcce25fcd025fcd225fbd324fbd524fbd724fad824fada24f9dc24f9dd25f8df25f8e125f7e225f7e425f6e626f6e826f5e926f5eb27f4ed27f3ee27f3f027f2f227f1f426f1f525f0f724f0f921"));function ym(t){return function(){return t}}const vm=Math.abs,_m=Math.atan2,bm=Math.cos,mm=Math.max,xm=Math.min,wm=Math.sin,Mm=Math.sqrt,Tm=1e-12,Am=Math.PI,Sm=Am/2,Em=2*Am;function Nm(t){return t>=1?Sm:t<=-1?-Sm:Math.asin(t)}function km(t){let n=3;return t.digits=function(e){if(!arguments.length)return n;if(null==e)n=null;else{const t=Math.floor(e);if(!(t>=0))throw new RangeError(`invalid digits: ${e}`);n=t}return t},()=>new Ua(n)}function Cm(t){return t.innerRadius}function Pm(t){return t.outerRadius}function zm(t){return t.startAngle}function $m(t){return t.endAngle}function Dm(t){return t&&t.padAngle}function Rm(t,n,e,r,i,o,a){var u=t-e,c=n-r,f=(a?o:-o)/Mm(u*u+c*c),s=f*c,l=-f*u,h=t+s,d=n+l,p=e+s,g=r+l,y=(h+p)/2,v=(d+g)/2,_=p-h,b=g-d,m=_*_+b*b,x=i-o,w=h*g-p*d,M=(b<0?-1:1)*Mm(mm(0,x*x*m-w*w)),T=(w*b-_*M)/m,A=(-w*_-b*M)/m,S=(w*b+_*M)/m,E=(-w*_+b*M)/m,N=T-y,k=A-v,C=S-y,P=E-v;return N*N+k*k>C*C+P*P&&(T=S,A=E),{cx:T,cy:A,x01:-s,y01:-l,x11:T*(i/x-1),y11:A*(i/x-1)}}var Fm=Array.prototype.slice;function qm(t){return"object"==typeof t&&"length"in t?t:Array.from(t)}function Um(t){this._context=t}function Im(t){return new Um(t)}function Om(t){return t[0]}function Bm(t){return t[1]}function Ym(t,n){var e=ym(!0),r=null,i=Im,o=null,a=km(u);function u(u){var c,f,s,l=(u=qm(u)).length,h=!1;for(null==r&&(o=i(s=a())),c=0;c<=l;++c)!(c=l;--h)u.point(v[h],_[h]);u.lineEnd(),u.areaEnd()}y&&(v[s]=+t(d,s,f),_[s]=+n(d,s,f),u.point(r?+r(d,s,f):v[s],e?+e(d,s,f):_[s]))}if(p)return u=null,p+""||null}function s(){return Ym().defined(i).curve(a).context(o)}return t="function"==typeof t?t:void 0===t?Om:ym(+t),n="function"==typeof n?n:ym(void 0===n?0:+n),e="function"==typeof e?e:void 0===e?Bm:ym(+e),f.x=function(n){return arguments.length?(t="function"==typeof n?n:ym(+n),r=null,f):t},f.x0=function(n){return arguments.length?(t="function"==typeof n?n:ym(+n),f):t},f.x1=function(t){return arguments.length?(r=null==t?null:"function"==typeof t?t:ym(+t),f):r},f.y=function(t){return arguments.length?(n="function"==typeof t?t:ym(+t),e=null,f):n},f.y0=function(t){return arguments.length?(n="function"==typeof t?t:ym(+t),f):n},f.y1=function(t){return arguments.length?(e=null==t?null:"function"==typeof t?t:ym(+t),f):e},f.lineX0=f.lineY0=function(){return s().x(t).y(n)},f.lineY1=function(){return s().x(t).y(e)},f.lineX1=function(){return s().x(r).y(n)},f.defined=function(t){return arguments.length?(i="function"==typeof t?t:ym(!!t),f):i},f.curve=function(t){return arguments.length?(a=t,null!=o&&(u=a(o)),f):a},f.context=function(t){return arguments.length?(null==t?o=u=null:u=a(o=t),f):o},f}function jm(t,n){return nt?1:n>=t?0:NaN}function Hm(t){return t}Um.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._point=0},lineEnd:function(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:this._context.lineTo(t,n)}}};var Xm=Vm(Im);function Gm(t){this._curve=t}function Vm(t){function n(n){return new Gm(t(n))}return n._curve=t,n}function Wm(t){var n=t.curve;return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t.curve=function(t){return arguments.length?n(Vm(t)):n()._curve},t}function Zm(){return Wm(Ym().curve(Xm))}function Km(){var t=Lm().curve(Xm),n=t.curve,e=t.lineX0,r=t.lineX1,i=t.lineY0,o=t.lineY1;return t.angle=t.x,delete t.x,t.startAngle=t.x0,delete t.x0,t.endAngle=t.x1,delete t.x1,t.radius=t.y,delete t.y,t.innerRadius=t.y0,delete t.y0,t.outerRadius=t.y1,delete t.y1,t.lineStartAngle=function(){return Wm(e())},delete t.lineX0,t.lineEndAngle=function(){return Wm(r())},delete t.lineX1,t.lineInnerRadius=function(){return Wm(i())},delete t.lineY0,t.lineOuterRadius=function(){return Wm(o())},delete t.lineY1,t.curve=function(t){return arguments.length?n(Vm(t)):n()._curve},t}function Qm(t,n){return[(n=+n)*Math.cos(t-=Math.PI/2),n*Math.sin(t)]}Gm.prototype={areaStart:function(){this._curve.areaStart()},areaEnd:function(){this._curve.areaEnd()},lineStart:function(){this._curve.lineStart()},lineEnd:function(){this._curve.lineEnd()},point:function(t,n){this._curve.point(n*Math.sin(t),n*-Math.cos(t))}};class Jm{constructor(t,n){this._context=t,this._x=n}areaStart(){this._line=0}areaEnd(){this._line=NaN}lineStart(){this._point=0}lineEnd(){(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line}point(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:this._x?this._context.bezierCurveTo(this._x0=(this._x0+t)/2,this._y0,this._x0,n,t,n):this._context.bezierCurveTo(this._x0,this._y0=(this._y0+n)/2,t,this._y0,t,n)}this._x0=t,this._y0=n}}class tx{constructor(t){this._context=t}lineStart(){this._point=0}lineEnd(){}point(t,n){if(t=+t,n=+n,0===this._point)this._point=1;else{const e=Qm(this._x0,this._y0),r=Qm(this._x0,this._y0=(this._y0+n)/2),i=Qm(t,this._y0),o=Qm(t,n);this._context.moveTo(...e),this._context.bezierCurveTo(...r,...i,...o)}this._x0=t,this._y0=n}}function nx(t){return new Jm(t,!0)}function ex(t){return new Jm(t,!1)}function rx(t){return new tx(t)}function ix(t){return t.source}function ox(t){return t.target}function ax(t){let n=ix,e=ox,r=Om,i=Bm,o=null,a=null,u=km(c);function c(){let c;const f=Fm.call(arguments),s=n.apply(this,f),l=e.apply(this,f);if(null==o&&(a=t(c=u())),a.lineStart(),f[0]=s,a.point(+r.apply(this,f),+i.apply(this,f)),f[0]=l,a.point(+r.apply(this,f),+i.apply(this,f)),a.lineEnd(),c)return a=null,c+""||null}return c.source=function(t){return arguments.length?(n=t,c):n},c.target=function(t){return arguments.length?(e=t,c):e},c.x=function(t){return arguments.length?(r="function"==typeof t?t:ym(+t),c):r},c.y=function(t){return arguments.length?(i="function"==typeof t?t:ym(+t),c):i},c.context=function(n){return arguments.length?(null==n?o=a=null:a=t(o=n),c):o},c}const ux=Mm(3);var cx={draw(t,n){const e=.59436*Mm(n+xm(n/28,.75)),r=e/2,i=r*ux;t.moveTo(0,e),t.lineTo(0,-e),t.moveTo(-i,-r),t.lineTo(i,r),t.moveTo(-i,r),t.lineTo(i,-r)}},fx={draw(t,n){const e=Mm(n/Am);t.moveTo(e,0),t.arc(0,0,e,0,Em)}},sx={draw(t,n){const e=Mm(n/5)/2;t.moveTo(-3*e,-e),t.lineTo(-e,-e),t.lineTo(-e,-3*e),t.lineTo(e,-3*e),t.lineTo(e,-e),t.lineTo(3*e,-e),t.lineTo(3*e,e),t.lineTo(e,e),t.lineTo(e,3*e),t.lineTo(-e,3*e),t.lineTo(-e,e),t.lineTo(-3*e,e),t.closePath()}};const lx=Mm(1/3),hx=2*lx;var dx={draw(t,n){const e=Mm(n/hx),r=e*lx;t.moveTo(0,-e),t.lineTo(r,0),t.lineTo(0,e),t.lineTo(-r,0),t.closePath()}},px={draw(t,n){const e=.62625*Mm(n);t.moveTo(0,-e),t.lineTo(e,0),t.lineTo(0,e),t.lineTo(-e,0),t.closePath()}},gx={draw(t,n){const e=.87559*Mm(n-xm(n/7,2));t.moveTo(-e,0),t.lineTo(e,0),t.moveTo(0,e),t.lineTo(0,-e)}},yx={draw(t,n){const e=Mm(n),r=-e/2;t.rect(r,r,e,e)}},vx={draw(t,n){const e=.4431*Mm(n);t.moveTo(e,e),t.lineTo(e,-e),t.lineTo(-e,-e),t.lineTo(-e,e),t.closePath()}};const _x=wm(Am/10)/wm(7*Am/10),bx=wm(Em/10)*_x,mx=-bm(Em/10)*_x;var xx={draw(t,n){const e=Mm(.8908130915292852*n),r=bx*e,i=mx*e;t.moveTo(0,-e),t.lineTo(r,i);for(let n=1;n<5;++n){const o=Em*n/5,a=bm(o),u=wm(o);t.lineTo(u*e,-a*e),t.lineTo(a*r-u*i,u*r+a*i)}t.closePath()}};const wx=Mm(3);var Mx={draw(t,n){const e=-Mm(n/(3*wx));t.moveTo(0,2*e),t.lineTo(-wx*e,-e),t.lineTo(wx*e,-e),t.closePath()}};const Tx=Mm(3);var Ax={draw(t,n){const e=.6824*Mm(n),r=e/2,i=e*Tx/2;t.moveTo(0,-e),t.lineTo(i,r),t.lineTo(-i,r),t.closePath()}};const Sx=-.5,Ex=Mm(3)/2,Nx=1/Mm(12),kx=3*(Nx/2+1);var Cx={draw(t,n){const e=Mm(n/kx),r=e/2,i=e*Nx,o=r,a=e*Nx+e,u=-o,c=a;t.moveTo(r,i),t.lineTo(o,a),t.lineTo(u,c),t.lineTo(Sx*r-Ex*i,Ex*r+Sx*i),t.lineTo(Sx*o-Ex*a,Ex*o+Sx*a),t.lineTo(Sx*u-Ex*c,Ex*u+Sx*c),t.lineTo(Sx*r+Ex*i,Sx*i-Ex*r),t.lineTo(Sx*o+Ex*a,Sx*a-Ex*o),t.lineTo(Sx*u+Ex*c,Sx*c-Ex*u),t.closePath()}},Px={draw(t,n){const e=.6189*Mm(n-xm(n/6,1.7));t.moveTo(-e,-e),t.lineTo(e,e),t.moveTo(-e,e),t.lineTo(e,-e)}};const zx=[fx,sx,dx,yx,xx,Mx,Cx],$x=[fx,gx,Px,Ax,cx,vx,px];function Dx(){}function Rx(t,n,e){t._context.bezierCurveTo((2*t._x0+t._x1)/3,(2*t._y0+t._y1)/3,(t._x0+2*t._x1)/3,(t._y0+2*t._y1)/3,(t._x0+4*t._x1+n)/6,(t._y0+4*t._y1+e)/6)}function Fx(t){this._context=t}function qx(t){this._context=t}function Ux(t){this._context=t}function Ix(t,n){this._basis=new Fx(t),this._beta=n}Fx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){switch(this._point){case 3:Rx(this,this._x1,this._y1);case 2:this._context.lineTo(this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3,this._context.lineTo((5*this._x0+this._x1)/6,(5*this._y0+this._y1)/6);default:Rx(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},qx.prototype={areaStart:Dx,areaEnd:Dx,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._y0=this._y1=this._y2=this._y3=this._y4=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x2,this._y2),this._context.closePath();break;case 2:this._context.moveTo((this._x2+2*this._x3)/3,(this._y2+2*this._y3)/3),this._context.lineTo((this._x3+2*this._x2)/3,(this._y3+2*this._y2)/3),this._context.closePath();break;case 3:this.point(this._x2,this._y2),this.point(this._x3,this._y3),this.point(this._x4,this._y4)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x2=t,this._y2=n;break;case 1:this._point=2,this._x3=t,this._y3=n;break;case 2:this._point=3,this._x4=t,this._y4=n,this._context.moveTo((this._x0+4*this._x1+t)/6,(this._y0+4*this._y1+n)/6);break;default:Rx(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},Ux.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._y0=this._y1=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3;var e=(this._x0+4*this._x1+t)/6,r=(this._y0+4*this._y1+n)/6;this._line?this._context.lineTo(e,r):this._context.moveTo(e,r);break;case 3:this._point=4;default:Rx(this,t,n)}this._x0=this._x1,this._x1=t,this._y0=this._y1,this._y1=n}},Ix.prototype={lineStart:function(){this._x=[],this._y=[],this._basis.lineStart()},lineEnd:function(){var t=this._x,n=this._y,e=t.length-1;if(e>0)for(var r,i=t[0],o=n[0],a=t[e]-i,u=n[e]-o,c=-1;++c<=e;)r=c/e,this._basis.point(this._beta*t[c]+(1-this._beta)*(i+r*a),this._beta*n[c]+(1-this._beta)*(o+r*u));this._x=this._y=null,this._basis.lineEnd()},point:function(t,n){this._x.push(+t),this._y.push(+n)}};var Ox=function t(n){function e(t){return 1===n?new Fx(t):new Ix(t,n)}return e.beta=function(n){return t(+n)},e}(.85);function Bx(t,n,e){t._context.bezierCurveTo(t._x1+t._k*(t._x2-t._x0),t._y1+t._k*(t._y2-t._y0),t._x2+t._k*(t._x1-n),t._y2+t._k*(t._y1-e),t._x2,t._y2)}function Yx(t,n){this._context=t,this._k=(1-n)/6}Yx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:Bx(this,this._x1,this._y1)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2,this._x1=t,this._y1=n;break;case 2:this._point=3;default:Bx(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Lx=function t(n){function e(t){return new Yx(t,n)}return e.tension=function(n){return t(+n)},e}(0);function jx(t,n){this._context=t,this._k=(1-n)/6}jx.prototype={areaStart:Dx,areaEnd:Dx,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:Bx(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Hx=function t(n){function e(t){return new jx(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Xx(t,n){this._context=t,this._k=(1-n)/6}Xx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Bx(this,t,n)}this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Gx=function t(n){function e(t){return new Xx(t,n)}return e.tension=function(n){return t(+n)},e}(0);function Vx(t,n,e){var r=t._x1,i=t._y1,o=t._x2,a=t._y2;if(t._l01_a>Tm){var u=2*t._l01_2a+3*t._l01_a*t._l12_a+t._l12_2a,c=3*t._l01_a*(t._l01_a+t._l12_a);r=(r*u-t._x0*t._l12_2a+t._x2*t._l01_2a)/c,i=(i*u-t._y0*t._l12_2a+t._y2*t._l01_2a)/c}if(t._l23_a>Tm){var f=2*t._l23_2a+3*t._l23_a*t._l12_a+t._l12_2a,s=3*t._l23_a*(t._l23_a+t._l12_a);o=(o*f+t._x1*t._l23_2a-n*t._l12_2a)/s,a=(a*f+t._y1*t._l23_2a-e*t._l12_2a)/s}t._context.bezierCurveTo(r,i,o,a,t._x2,t._y2)}function Wx(t,n){this._context=t,this._alpha=n}Wx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 2:this._context.lineTo(this._x2,this._y2);break;case 3:this.point(this._x2,this._y2)}(this._line||0!==this._line&&1===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;break;case 2:this._point=3;default:Vx(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Zx=function t(n){function e(t){return n?new Wx(t,n):new Yx(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function Kx(t,n){this._context=t,this._alpha=n}Kx.prototype={areaStart:Dx,areaEnd:Dx,lineStart:function(){this._x0=this._x1=this._x2=this._x3=this._x4=this._x5=this._y0=this._y1=this._y2=this._y3=this._y4=this._y5=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){switch(this._point){case 1:this._context.moveTo(this._x3,this._y3),this._context.closePath();break;case 2:this._context.lineTo(this._x3,this._y3),this._context.closePath();break;case 3:this.point(this._x3,this._y3),this.point(this._x4,this._y4),this.point(this._x5,this._y5)}},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1,this._x3=t,this._y3=n;break;case 1:this._point=2,this._context.moveTo(this._x4=t,this._y4=n);break;case 2:this._point=3,this._x5=t,this._y5=n;break;default:Vx(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var Qx=function t(n){function e(t){return n?new Kx(t,n):new jx(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function Jx(t,n){this._context=t,this._alpha=n}Jx.prototype={areaStart:function(){this._line=0},areaEnd:function(){this._line=NaN},lineStart:function(){this._x0=this._x1=this._x2=this._y0=this._y1=this._y2=NaN,this._l01_a=this._l12_a=this._l23_a=this._l01_2a=this._l12_2a=this._l23_2a=this._point=0},lineEnd:function(){(this._line||0!==this._line&&3===this._point)&&this._context.closePath(),this._line=1-this._line},point:function(t,n){if(t=+t,n=+n,this._point){var e=this._x2-t,r=this._y2-n;this._l23_a=Math.sqrt(this._l23_2a=Math.pow(e*e+r*r,this._alpha))}switch(this._point){case 0:this._point=1;break;case 1:this._point=2;break;case 2:this._point=3,this._line?this._context.lineTo(this._x2,this._y2):this._context.moveTo(this._x2,this._y2);break;case 3:this._point=4;default:Vx(this,t,n)}this._l01_a=this._l12_a,this._l12_a=this._l23_a,this._l01_2a=this._l12_2a,this._l12_2a=this._l23_2a,this._x0=this._x1,this._x1=this._x2,this._x2=t,this._y0=this._y1,this._y1=this._y2,this._y2=n}};var tw=function t(n){function e(t){return n?new Jx(t,n):new Xx(t,0)}return e.alpha=function(n){return t(+n)},e}(.5);function nw(t){this._context=t}function ew(t){return t<0?-1:1}function rw(t,n,e){var r=t._x1-t._x0,i=n-t._x1,o=(t._y1-t._y0)/(r||i<0&&-0),a=(e-t._y1)/(i||r<0&&-0),u=(o*i+a*r)/(r+i);return(ew(o)+ew(a))*Math.min(Math.abs(o),Math.abs(a),.5*Math.abs(u))||0}function iw(t,n){var e=t._x1-t._x0;return e?(3*(t._y1-t._y0)/e-n)/2:n}function ow(t,n,e){var r=t._x0,i=t._y0,o=t._x1,a=t._y1,u=(o-r)/3;t._context.bezierCurveTo(r+u,i+u*n,o-u,a-u*e,o,a)}function aw(t){this._context=t}function uw(t){this._context=new cw(t)}function cw(t){this._context=t}function fw(t){this._context=t}function sw(t){var n,e,r=t.length-1,i=new Array(r),o=new Array(r),a=new Array(r);for(i[0]=0,o[0]=2,a[0]=t[0]+2*t[1],n=1;n=0;--n)i[n]=(a[n]-i[n+1])/o[n];for(o[r-1]=(t[r]+i[r-1])/2,n=0;n1)for(var e,r,i,o=1,a=t[n[0]],u=a.length;o=0;)e[n]=n;return e}function pw(t,n){return t[n]}function gw(t){const n=[];return n.key=t,n}function yw(t){var n=t.map(vw);return dw(t).sort((function(t,e){return n[t]-n[e]}))}function vw(t){for(var n,e=-1,r=0,i=t.length,o=-1/0;++eo&&(o=n,r=e);return r}function _w(t){var n=t.map(bw);return dw(t).sort((function(t,e){return n[t]-n[e]}))}function bw(t){for(var n,e=0,r=-1,i=t.length;++r=0&&(this._t=1-this._t,this._line=1-this._line)},point:function(t,n){switch(t=+t,n=+n,this._point){case 0:this._point=1,this._line?this._context.lineTo(t,n):this._context.moveTo(t,n);break;case 1:this._point=2;default:if(this._t<=0)this._context.lineTo(this._x,n),this._context.lineTo(t,n);else{var e=this._x*(1-this._t)+t*this._t;this._context.lineTo(e,this._y),this._context.lineTo(e,n)}}this._x=t,this._y=n}};var mw=t=>()=>t;function xw(t,{sourceEvent:n,target:e,transform:r,dispatch:i}){Object.defineProperties(this,{type:{value:t,enumerable:!0,configurable:!0},sourceEvent:{value:n,enumerable:!0,configurable:!0},target:{value:e,enumerable:!0,configurable:!0},transform:{value:r,enumerable:!0,configurable:!0},_:{value:i}})}function ww(t,n,e){this.k=t,this.x=n,this.y=e}ww.prototype={constructor:ww,scale:function(t){return 1===t?this:new ww(this.k*t,this.x,this.y)},translate:function(t,n){return 0===t&0===n?this:new ww(this.k,this.x+this.k*t,this.y+this.k*n)},apply:function(t){return[t[0]*this.k+this.x,t[1]*this.k+this.y]},applyX:function(t){return t*this.k+this.x},applyY:function(t){return t*this.k+this.y},invert:function(t){return[(t[0]-this.x)/this.k,(t[1]-this.y)/this.k]},invertX:function(t){return(t-this.x)/this.k},invertY:function(t){return(t-this.y)/this.k},rescaleX:function(t){return t.copy().domain(t.range().map(this.invertX,this).map(t.invert,t))},rescaleY:function(t){return t.copy().domain(t.range().map(this.invertY,this).map(t.invert,t))},toString:function(){return"translate("+this.x+","+this.y+") scale("+this.k+")"}};var Mw=new ww(1,0,0);function Tw(t){for(;!t.__zoom;)if(!(t=t.parentNode))return Mw;return t.__zoom}function Aw(t){t.stopImmediatePropagation()}function Sw(t){t.preventDefault(),t.stopImmediatePropagation()}function Ew(t){return!(t.ctrlKey&&"wheel"!==t.type||t.button)}function Nw(){var t=this;return t instanceof SVGElement?(t=t.ownerSVGElement||t).hasAttribute("viewBox")?[[(t=t.viewBox.baseVal).x,t.y],[t.x+t.width,t.y+t.height]]:[[0,0],[t.width.baseVal.value,t.height.baseVal.value]]:[[0,0],[t.clientWidth,t.clientHeight]]}function kw(){return this.__zoom||Mw}function Cw(t){return-t.deltaY*(1===t.deltaMode?.05:t.deltaMode?1:.002)*(t.ctrlKey?10:1)}function Pw(){return navigator.maxTouchPoints||"ontouchstart"in this}function zw(t,n,e){var r=t.invertX(n[0][0])-e[0][0],i=t.invertX(n[1][0])-e[1][0],o=t.invertY(n[0][1])-e[0][1],a=t.invertY(n[1][1])-e[1][1];return t.translate(i>r?(r+i)/2:Math.min(0,r)||Math.max(0,i),a>o?(o+a)/2:Math.min(0,o)||Math.max(0,a))}Tw.prototype=ww.prototype,t.Adder=T,t.Delaunay=Lu,t.FormatSpecifier=tf,t.InternMap=InternMap,t.InternSet=InternSet,t.Node=Qd,t.Path=Ua,t.Voronoi=qu,t.ZoomTransform=ww,t.active=function(t,n){var e,r,i=t.__transition;if(i)for(r in n=null==n?null:n+"",i)if((e=i[r]).state>qi&&e.name===n)return new po([[t]],Zo,n,+r);return null},t.arc=function(){var t=Cm,n=Pm,e=ym(0),r=null,i=zm,o=$m,a=Dm,u=null,c=km(f);function f(){var f,s,l=+t.apply(this,arguments),h=+n.apply(this,arguments),d=i.apply(this,arguments)-Sm,p=o.apply(this,arguments)-Sm,g=vm(p-d),y=p>d;if(u||(u=f=c()),hTm)if(g>Em-Tm)u.moveTo(h*bm(d),h*wm(d)),u.arc(0,0,h,d,p,!y),l>Tm&&(u.moveTo(l*bm(p),l*wm(p)),u.arc(0,0,l,p,d,y));else{var v,_,b=d,m=p,x=d,w=p,M=g,T=g,A=a.apply(this,arguments)/2,S=A>Tm&&(r?+r.apply(this,arguments):Mm(l*l+h*h)),E=xm(vm(h-l)/2,+e.apply(this,arguments)),N=E,k=E;if(S>Tm){var C=Nm(S/l*wm(A)),P=Nm(S/h*wm(A));(M-=2*C)>Tm?(x+=C*=y?1:-1,w-=C):(M=0,x=w=(d+p)/2),(T-=2*P)>Tm?(b+=P*=y?1:-1,m-=P):(T=0,b=m=(d+p)/2)}var z=h*bm(b),$=h*wm(b),D=l*bm(w),R=l*wm(w);if(E>Tm){var F,q=h*bm(m),U=h*wm(m),I=l*bm(x),O=l*wm(x);if(g1?0:t<-1?Am:Math.acos(t)}((B*L+Y*j)/(Mm(B*B+Y*Y)*Mm(L*L+j*j)))/2),X=Mm(F[0]*F[0]+F[1]*F[1]);N=xm(E,(l-X)/(H-1)),k=xm(E,(h-X)/(H+1))}else N=k=0}T>Tm?k>Tm?(v=Rm(I,O,z,$,h,k,y),_=Rm(q,U,D,R,h,k,y),u.moveTo(v.cx+v.x01,v.cy+v.y01),kTm&&M>Tm?N>Tm?(v=Rm(D,R,q,U,l,-N,y),_=Rm(z,$,I,O,l,-N,y),u.lineTo(v.cx+v.x01,v.cy+v.y01),N=0))throw new RangeError("invalid r");let e=t.length;if(!((e=Math.floor(e))>=0))throw new RangeError("invalid length");if(!e||!n)return t;const r=y(n),i=t.slice();return r(t,i,0,e,1),r(i,t,0,e,1),r(t,i,0,e,1),t},t.blur2=l,t.blurImage=h,t.brush=function(){return wa(la)},t.brushSelection=function(t){var n=t.__brush;return n?n.dim.output(n.selection):null},t.brushX=function(){return wa(fa)},t.brushY=function(){return wa(sa)},t.buffer=function(t,n){return fetch(t,n).then(_c)},t.chord=function(){return za(!1,!1)},t.chordDirected=function(){return za(!0,!1)},t.chordTranspose=function(){return za(!1,!0)},t.cluster=function(){var t=Ld,n=1,e=1,r=!1;function i(i){var o,a=0;i.eachAfter((function(n){var e=n.children;e?(n.x=function(t){return t.reduce(jd,0)/t.length}(e),n.y=function(t){return 1+t.reduce(Hd,0)}(e)):(n.x=o?a+=t(n,o):0,n.y=0,o=n)}));var u=function(t){for(var n;n=t.children;)t=n[0];return t}(i),c=function(t){for(var n;n=t.children;)t=n[n.length-1];return t}(i),f=u.x-t(u,c)/2,s=c.x+t(c,u)/2;return i.eachAfter(r?function(t){t.x=(t.x-i.x)*n,t.y=(i.y-t.y)*e}:function(t){t.x=(t.x-f)/(s-f)*n,t.y=(1-(i.y?t.y/i.y:1))*e})}return i.separation=function(n){return arguments.length?(t=n,i):t},i.size=function(t){return arguments.length?(r=!1,n=+t[0],e=+t[1],i):r?null:[n,e]},i.nodeSize=function(t){return arguments.length?(r=!0,n=+t[0],e=+t[1],i):r?[n,e]:null},i},t.color=ze,t.contourDensity=function(){var t=fu,n=su,e=lu,r=960,i=500,o=20,a=2,u=3*o,c=r+2*u>>a,f=i+2*u>>a,s=Qa(20);function h(r){var i=new Float32Array(c*f),s=Math.pow(2,-a),h=-1;for(const o of r){var d=(t(o,++h,r)+u)*s,p=(n(o,h,r)+u)*s,g=+e(o,h,r);if(g&&d>=0&&d=0&&pt*r)))(n).map(((t,n)=>(t.value=+e[n],p(t))))}function p(t){return t.coordinates.forEach(g),t}function g(t){t.forEach(y)}function y(t){t.forEach(v)}function v(t){t[0]=t[0]*Math.pow(2,a)-u,t[1]=t[1]*Math.pow(2,a)-u}function _(){return c=r+2*(u=3*o)>>a,f=i+2*u>>a,d}return d.contours=function(t){var n=h(t),e=iu().size([c,f]),r=Math.pow(2,2*a),i=t=>{t=+t;var i=p(e.contour(n,t*r));return i.value=t,i};return Object.defineProperty(i,"max",{get:()=>J(n)/r}),i},d.x=function(n){return arguments.length?(t="function"==typeof n?n:Qa(+n),d):t},d.y=function(t){return arguments.length?(n="function"==typeof t?t:Qa(+t),d):n},d.weight=function(t){return arguments.length?(e="function"==typeof t?t:Qa(+t),d):e},d.size=function(t){if(!arguments.length)return[r,i];var n=+t[0],e=+t[1];if(!(n>=0&&e>=0))throw new Error("invalid size");return r=n,i=e,_()},d.cellSize=function(t){if(!arguments.length)return 1<=1))throw new Error("invalid cell size");return a=Math.floor(Math.log(t)/Math.LN2),_()},d.thresholds=function(t){return arguments.length?(s="function"==typeof t?t:Array.isArray(t)?Qa(Za.call(t)):Qa(t),d):s},d.bandwidth=function(t){if(!arguments.length)return Math.sqrt(o*(o+1));if(!((t=+t)>=0))throw new Error("invalid bandwidth");return o=(Math.sqrt(4*t*t+1)-1)/2,_()},d},t.contours=iu,t.count=v,t.create=function(t){return Zn(Yt(t).call(document.documentElement))},t.creator=Yt,t.cross=function(...t){const n="function"==typeof t[t.length-1]&&function(t){return n=>t(...n)}(t.pop()),e=(t=t.map(m)).map(_),r=t.length-1,i=new Array(r+1).fill(0),o=[];if(r<0||e.some(b))return o;for(;;){o.push(i.map(((n,e)=>t[e][n])));let a=r;for(;++i[a]===e[a];){if(0===a)return n?o.map(n):o;i[a--]=0}}},t.csv=wc,t.csvFormat=rc,t.csvFormatBody=ic,t.csvFormatRow=ac,t.csvFormatRows=oc,t.csvFormatValue=uc,t.csvParse=nc,t.csvParseRows=ec,t.cubehelix=Tr,t.cumsum=function(t,n){var e=0,r=0;return Float64Array.from(t,void 0===n?t=>e+=+t||0:i=>e+=+n(i,r++,t)||0)},t.curveBasis=function(t){return new Fx(t)},t.curveBasisClosed=function(t){return new qx(t)},t.curveBasisOpen=function(t){return new Ux(t)},t.curveBumpX=nx,t.curveBumpY=ex,t.curveBundle=Ox,t.curveCardinal=Lx,t.curveCardinalClosed=Hx,t.curveCardinalOpen=Gx,t.curveCatmullRom=Zx,t.curveCatmullRomClosed=Qx,t.curveCatmullRomOpen=tw,t.curveLinear=Im,t.curveLinearClosed=function(t){return new nw(t)},t.curveMonotoneX=function(t){return new aw(t)},t.curveMonotoneY=function(t){return new uw(t)},t.curveNatural=function(t){return new fw(t)},t.curveStep=function(t){return new lw(t,.5)},t.curveStepAfter=function(t){return new lw(t,1)},t.curveStepBefore=function(t){return new lw(t,0)},t.descending=e,t.deviation=w,t.difference=function(t,...n){t=new InternSet(t);for(const e of n)for(const n of e)t.delete(n);return t},t.disjoint=function(t,n){const e=n[Symbol.iterator](),r=new InternSet;for(const n of t){if(r.has(n))return!1;let t,i;for(;({value:t,done:i}=e.next())&&!i;){if(Object.is(n,t))return!1;r.add(t)}}return!0},t.dispatch=$t,t.drag=function(){var t,n,e,r,i=se,o=le,a=he,u=de,c={},f=$t("start","drag","end"),s=0,l=0;function h(t){t.on("mousedown.drag",d).filter(u).on("touchstart.drag",y).on("touchmove.drag",v,ee).on("touchend.drag touchcancel.drag",_).style("touch-action","none").style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function d(a,u){if(!r&&i.call(this,a,u)){var c=b(this,o.call(this,a,u),a,u,"mouse");c&&(Zn(a.view).on("mousemove.drag",p,re).on("mouseup.drag",g,re),ae(a.view),ie(a),e=!1,t=a.clientX,n=a.clientY,c("start",a))}}function p(r){if(oe(r),!e){var i=r.clientX-t,o=r.clientY-n;e=i*i+o*o>l}c.mouse("drag",r)}function g(t){Zn(t.view).on("mousemove.drag mouseup.drag",null),ue(t.view,e),oe(t),c.mouse("end",t)}function y(t,n){if(i.call(this,t,n)){var e,r,a=t.changedTouches,u=o.call(this,t,n),c=a.length;for(e=0;e+t,t.easePoly=wo,t.easePolyIn=mo,t.easePolyInOut=wo,t.easePolyOut=xo,t.easeQuad=_o,t.easeQuadIn=function(t){return t*t},t.easeQuadInOut=_o,t.easeQuadOut=function(t){return t*(2-t)},t.easeSin=Ao,t.easeSinIn=function(t){return 1==+t?1:1-Math.cos(t*To)},t.easeSinInOut=Ao,t.easeSinOut=function(t){return Math.sin(t*To)},t.every=function(t,n){if("function"!=typeof n)throw new TypeError("test is not a function");let e=-1;for(const r of t)if(!n(r,++e,t))return!1;return!0},t.extent=M,t.fcumsum=function(t,n){const e=new T;let r=-1;return Float64Array.from(t,void 0===n?t=>e.add(+t||0):i=>e.add(+n(i,++r,t)||0))},t.filter=function(t,n){if("function"!=typeof n)throw new TypeError("test is not a function");const e=[];let r=-1;for(const i of t)n(i,++r,t)&&e.push(i);return e},t.flatGroup=function(t,...n){return z(P(t,...n),n)},t.flatRollup=function(t,n,...e){return z(D(t,n,...e),e)},t.forceCenter=function(t,n){var e,r=1;function i(){var i,o,a=e.length,u=0,c=0;for(i=0;if+p||os+p||ac.index){var g=f-u.x-u.vx,y=s-u.y-u.vy,v=g*g+y*y;vt.r&&(t.r=t[n].r)}function c(){if(n){var r,i,o=n.length;for(e=new Array(o),r=0;r[u(t,n,r),t])));for(a=0,i=new Array(f);a=u)){(t.data!==n||t.next)&&(0===l&&(p+=(l=Uc(e))*l),0===h&&(p+=(h=Uc(e))*h),p(t=(Lc*t+jc)%Hc)/Hc}();function l(){h(),f.call("tick",n),e1?(null==e?u.delete(t):u.set(t,p(e)),n):u.get(t)},find:function(n,e,r){var i,o,a,u,c,f=0,s=t.length;for(null==r?r=1/0:r*=r,f=0;f1?(f.on(t,e),n):f.on(t)}}},t.forceX=function(t){var n,e,r,i=qc(.1);function o(t){for(var i,o=0,a=n.length;o=.12&&i<.234&&r>=-.425&&r<-.214?u:i>=.166&&i<.234&&r>=-.214&&r<-.115?c:a).invert(t)},s.stream=function(e){return t&&n===e?t:(r=[a.stream(n=e),u.stream(e),c.stream(e)],i=r.length,t={point:function(t,n){for(var e=-1;++ejs(r[0],r[1])&&(r[1]=i[1]),js(i[0],r[1])>js(r[0],r[1])&&(r[0]=i[0])):o.push(r=i);for(a=-1/0,n=0,r=o[e=o.length-1];n<=e;r=i,++n)i=o[n],(u=js(r[1],i[0]))>a&&(a=u,Wf=i[0],Kf=r[1])}return is=os=null,Wf===1/0||Zf===1/0?[[NaN,NaN],[NaN,NaN]]:[[Wf,Zf],[Kf,Qf]]},t.geoCentroid=function(t){ms=xs=ws=Ms=Ts=As=Ss=Es=0,Ns=new T,ks=new T,Cs=new T,Lf(t,Gs);var n=+Ns,e=+ks,r=+Cs,i=Ef(n,e,r);return i=0))throw new RangeError(`invalid digits: ${t}`);i=n}return null===n&&(r=new ed(i)),a},a.projection(t).digits(i).context(n)},t.geoProjection=yd,t.geoProjectionMutator=vd,t.geoRotation=ll,t.geoStereographic=function(){return yd(Bd).scale(250).clipAngle(142)},t.geoStereographicRaw=Bd,t.geoStream=Lf,t.geoTransform=function(t){return{stream:id(t)}},t.geoTransverseMercator=function(){var t=Ed(Yd),n=t.center,e=t.rotate;return t.center=function(t){return arguments.length?n([-t[1],t[0]]):[(t=n())[1],-t[0]]},t.rotate=function(t){return arguments.length?e([t[0],t[1],t.length>2?t[2]+90:90]):[(t=e())[0],t[1],t[2]-90]},e([0,0,90]).scale(159.155)},t.geoTransverseMercatorRaw=Yd,t.gray=function(t,n){return new ur(t,0,0,null==n?1:n)},t.greatest=ot,t.greatestIndex=function(t,e=n){if(1===e.length)return tt(t,e);let r,i=-1,o=-1;for(const n of t)++o,(i<0?0===e(n,n):e(n,r)>0)&&(r=n,i=o);return i},t.group=C,t.groupSort=function(t,e,r){return(2!==e.length?U($(t,e,r),(([t,e],[r,i])=>n(e,i)||n(t,r))):U(C(t,r),(([t,r],[i,o])=>e(r,o)||n(t,i)))).map((([t])=>t))},t.groups=P,t.hcl=dr,t.hierarchy=Gd,t.histogram=Q,t.hsl=He,t.html=Ec,t.image=function(t,n){return new Promise((function(e,r){var i=new Image;for(var o in n)i[o]=n[o];i.onerror=r,i.onload=function(){e(i)},i.src=t}))},t.index=function(t,...n){return F(t,k,R,n)},t.indexes=function(t,...n){return F(t,Array.from,R,n)},t.interpolate=Gr,t.interpolateArray=function(t,n){return(Ir(n)?Ur:Or)(t,n)},t.interpolateBasis=Er,t.interpolateBasisClosed=Nr,t.interpolateBlues=Gb,t.interpolateBrBG=ob,t.interpolateBuGn=Mb,t.interpolateBuPu=Ab,t.interpolateCividis=function(t){return t=Math.max(0,Math.min(1,t)),"rgb("+Math.max(0,Math.min(255,Math.round(-4.54-t*(35.34-t*(2381.73-t*(6402.7-t*(7024.72-2710.57*t)))))))+", "+Math.max(0,Math.min(255,Math.round(32.49+t*(170.73+t*(52.82-t*(131.46-t*(176.58-67.37*t)))))))+", "+Math.max(0,Math.min(255,Math.round(81.24+t*(442.36-t*(2482.43-t*(6167.24-t*(6614.94-2475.67*t)))))))+")"},t.interpolateCool=am,t.interpolateCubehelix=li,t.interpolateCubehelixDefault=im,t.interpolateCubehelixLong=hi,t.interpolateDate=Br,t.interpolateDiscrete=function(t){var n=t.length;return function(e){return t[Math.max(0,Math.min(n-1,Math.floor(e*n)))]}},t.interpolateGnBu=Eb,t.interpolateGreens=Wb,t.interpolateGreys=Kb,t.interpolateHcl=ci,t.interpolateHclLong=fi,t.interpolateHsl=oi,t.interpolateHslLong=ai,t.interpolateHue=function(t,n){var e=Pr(+t,+n);return function(t){var n=e(t);return n-360*Math.floor(n/360)}},t.interpolateInferno=pm,t.interpolateLab=function(t,n){var e=$r((t=ar(t)).l,(n=ar(n)).l),r=$r(t.a,n.a),i=$r(t.b,n.b),o=$r(t.opacity,n.opacity);return function(n){return t.l=e(n),t.a=r(n),t.b=i(n),t.opacity=o(n),t+""}},t.interpolateMagma=dm,t.interpolateNumber=Yr,t.interpolateNumberArray=Ur,t.interpolateObject=Lr,t.interpolateOrRd=kb,t.interpolateOranges=rm,t.interpolatePRGn=ub,t.interpolatePiYG=fb,t.interpolatePlasma=gm,t.interpolatePuBu=$b,t.interpolatePuBuGn=Pb,t.interpolatePuOr=lb,t.interpolatePuRd=Rb,t.interpolatePurples=Jb,t.interpolateRainbow=function(t){(t<0||t>1)&&(t-=Math.floor(t));var n=Math.abs(t-.5);return um.h=360*t-100,um.s=1.5-1.5*n,um.l=.8-.9*n,um+""},t.interpolateRdBu=db,t.interpolateRdGy=gb,t.interpolateRdPu=qb,t.interpolateRdYlBu=vb,t.interpolateRdYlGn=bb,t.interpolateReds=nm,t.interpolateRgb=Dr,t.interpolateRgbBasis=Fr,t.interpolateRgbBasisClosed=qr,t.interpolateRound=Vr,t.interpolateSinebow=function(t){var n;return t=(.5-t)*Math.PI,cm.r=255*(n=Math.sin(t))*n,cm.g=255*(n=Math.sin(t+fm))*n,cm.b=255*(n=Math.sin(t+sm))*n,cm+""},t.interpolateSpectral=xb,t.interpolateString=Xr,t.interpolateTransformCss=ti,t.interpolateTransformSvg=ni,t.interpolateTurbo=function(t){return t=Math.max(0,Math.min(1,t)),"rgb("+Math.max(0,Math.min(255,Math.round(34.61+t*(1172.33-t*(10793.56-t*(33300.12-t*(38394.49-14825.05*t)))))))+", "+Math.max(0,Math.min(255,Math.round(23.31+t*(557.33+t*(1225.33-t*(3574.96-t*(1073.77+707.56*t)))))))+", "+Math.max(0,Math.min(255,Math.round(27.2+t*(3211.1-t*(15327.97-t*(27814-t*(22569.18-6838.66*t)))))))+")"},t.interpolateViridis=hm,t.interpolateWarm=om,t.interpolateYlGn=Bb,t.interpolateYlGnBu=Ib,t.interpolateYlOrBr=Lb,t.interpolateYlOrRd=Hb,t.interpolateZoom=ri,t.interrupt=Gi,t.intersection=function(t,...n){t=new InternSet(t),n=n.map(vt);t:for(const e of t)for(const r of n)if(!r.has(e)){t.delete(e);continue t}return t},t.interval=function(t,n,e){var r=new Ei,i=n;return null==n?(r.restart(t,n,e),r):(r._restart=r.restart,r.restart=function(t,n,e){n=+n,e=null==e?Ai():+e,r._restart((function o(a){a+=i,r._restart(o,i+=n,e),t(a)}),n,e)},r.restart(t,n,e),r)},t.isoFormat=D_,t.isoParse=F_,t.json=function(t,n){return fetch(t,n).then(Tc)},t.lab=ar,t.lch=function(t,n,e,r){return 1===arguments.length?hr(t):new pr(e,n,t,null==r?1:r)},t.least=function(t,e=n){let r,i=!1;if(1===e.length){let o;for(const a of t){const t=e(a);(i?n(t,o)<0:0===n(t,t))&&(r=a,o=t,i=!0)}}else for(const n of t)(i?e(n,r)<0:0===e(n,n))&&(r=n,i=!0);return r},t.leastIndex=ht,t.line=Ym,t.lineRadial=Zm,t.link=ax,t.linkHorizontal=function(){return ax(nx)},t.linkRadial=function(){const t=ax(rx);return t.angle=t.x,delete t.x,t.radius=t.y,delete t.y,t},t.linkVertical=function(){return ax(ex)},t.local=Qn,t.map=function(t,n){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");if("function"!=typeof n)throw new TypeError("mapper is not a function");return Array.from(t,((e,r)=>n(e,r,t)))},t.matcher=Vt,t.max=J,t.maxIndex=tt,t.mean=function(t,n){let e=0,r=0;if(void 0===n)for(let n of t)null!=n&&(n=+n)>=n&&(++e,r+=n);else{let i=-1;for(let o of t)null!=(o=n(o,++i,t))&&(o=+o)>=o&&(++e,r+=o)}if(e)return r/e},t.median=function(t,n){return at(t,.5,n)},t.medianIndex=function(t,n){return ct(t,.5,n)},t.merge=ft,t.min=nt,t.minIndex=et,t.mode=function(t,n){const e=new InternMap;if(void 0===n)for(let n of t)null!=n&&n>=n&&e.set(n,(e.get(n)||0)+1);else{let r=-1;for(let i of t)null!=(i=n(i,++r,t))&&i>=i&&e.set(i,(e.get(i)||0)+1)}let r,i=0;for(const[t,n]of e)n>i&&(i=n,r=t);return r},t.namespace=It,t.namespaces=Ut,t.nice=Z,t.now=Ai,t.pack=function(){var t=null,n=1,e=1,r=np;function i(i){const o=ap();return i.x=n/2,i.y=e/2,t?i.eachBefore(xp(t)).eachAfter(wp(r,.5,o)).eachBefore(Mp(1)):i.eachBefore(xp(mp)).eachAfter(wp(np,1,o)).eachAfter(wp(r,i.r/Math.min(n,e),o)).eachBefore(Mp(Math.min(n,e)/(2*i.r))),i}return i.radius=function(n){return arguments.length?(t=Jd(n),i):t},i.size=function(t){return arguments.length?(n=+t[0],e=+t[1],i):[n,e]},i.padding=function(t){return arguments.length?(r="function"==typeof t?t:ep(+t),i):r},i},t.packEnclose=function(t){return up(t,ap())},t.packSiblings=function(t){return bp(t,ap()),t},t.pairs=function(t,n=st){const e=[];let r,i=!1;for(const o of t)i&&e.push(n(r,o)),r=o,i=!0;return e},t.partition=function(){var t=1,n=1,e=0,r=!1;function i(i){var o=i.height+1;return i.x0=i.y0=e,i.x1=t,i.y1=n/o,i.eachBefore(function(t,n){return function(r){r.children&&Ap(r,r.x0,t*(r.depth+1)/n,r.x1,t*(r.depth+2)/n);var i=r.x0,o=r.y0,a=r.x1-e,u=r.y1-e;a0&&(d+=l);for(null!=n?p.sort((function(t,e){return n(g[t],g[e])})):null!=e&&p.sort((function(t,n){return e(a[t],a[n])})),u=0,f=d?(v-h*b)/d:0;u0?l*f:0)+b,g[c]={data:a[c],index:u,value:l,startAngle:y,endAngle:s,padAngle:_};return g}return a.value=function(n){return arguments.length?(t="function"==typeof n?n:ym(+n),a):t},a.sortValues=function(t){return arguments.length?(n=t,e=null,a):n},a.sort=function(t){return arguments.length?(e=t,n=null,a):e},a.startAngle=function(t){return arguments.length?(r="function"==typeof t?t:ym(+t),a):r},a.endAngle=function(t){return arguments.length?(i="function"==typeof t?t:ym(+t),a):i},a.padAngle=function(t){return arguments.length?(o="function"==typeof t?t:ym(+t),a):o},a},t.piecewise=di,t.pointRadial=Qm,t.pointer=ne,t.pointers=function(t,n){return t.target&&(t=te(t),void 0===n&&(n=t.currentTarget),t=t.touches||[t]),Array.from(t,(t=>ne(t,n)))},t.polygonArea=function(t){for(var n,e=-1,r=t.length,i=t[r-1],o=0;++eu!=f>u&&a<(c-e)*(u-r)/(f-r)+e&&(s=!s),c=e,f=r;return s},t.polygonHull=function(t){if((e=t.length)<3)return null;var n,e,r=new Array(e),i=new Array(e);for(n=0;n=0;--n)f.push(t[r[o[n]][2]]);for(n=+u;n(n=1664525*n+1013904223|0,lg*(n>>>0))},t.randomLogNormal=Kp,t.randomLogistic=fg,t.randomNormal=Zp,t.randomPareto=ng,t.randomPoisson=sg,t.randomUniform=Vp,t.randomWeibull=ug,t.range=lt,t.rank=function(t,e=n){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");let r=Array.from(t);const i=new Float64Array(r.length);2!==e.length&&(r=r.map(e),e=n);const o=(t,n)=>e(r[t],r[n]);let a,u;return(t=Uint32Array.from(r,((t,n)=>n))).sort(e===n?(t,n)=>O(r[t],r[n]):I(o)),t.forEach(((t,n)=>{const e=o(t,void 0===a?t:a);e>=0?((void 0===a||e>0)&&(a=t,u=n),i[t]=u):i[t]=NaN})),i},t.reduce=function(t,n,e){if("function"!=typeof n)throw new TypeError("reducer is not a function");const r=t[Symbol.iterator]();let i,o,a=-1;if(arguments.length<3){if(({done:i,value:e}=r.next()),i)return;++a}for(;({done:i,value:o}=r.next()),!i;)e=n(e,o,++a,t);return e},t.reverse=function(t){if("function"!=typeof t[Symbol.iterator])throw new TypeError("values is not iterable");return Array.from(t).reverse()},t.rgb=Fe,t.ribbon=function(){return Wa()},t.ribbonArrow=function(){return Wa(Va)},t.rollup=$,t.rollups=D,t.scaleBand=yg,t.scaleDiverging=function t(){var n=Ng(L_()(mg));return n.copy=function(){return B_(n,t())},dg.apply(n,arguments)},t.scaleDivergingLog=function t(){var n=Fg(L_()).domain([.1,1,10]);return n.copy=function(){return B_(n,t()).base(n.base())},dg.apply(n,arguments)},t.scaleDivergingPow=j_,t.scaleDivergingSqrt=function(){return j_.apply(null,arguments).exponent(.5)},t.scaleDivergingSymlog=function t(){var n=Ig(L_());return n.copy=function(){return B_(n,t()).constant(n.constant())},dg.apply(n,arguments)},t.scaleIdentity=function t(n){var e;function r(t){return null==t||isNaN(t=+t)?e:t}return r.invert=r,r.domain=r.range=function(t){return arguments.length?(n=Array.from(t,_g),r):n.slice()},r.unknown=function(t){return arguments.length?(e=t,r):e},r.copy=function(){return t(n).unknown(e)},n=arguments.length?Array.from(n,_g):[0,1],Ng(r)},t.scaleImplicit=pg,t.scaleLinear=function t(){var n=Sg();return n.copy=function(){return Tg(n,t())},hg.apply(n,arguments),Ng(n)},t.scaleLog=function t(){const n=Fg(Ag()).domain([1,10]);return n.copy=()=>Tg(n,t()).base(n.base()),hg.apply(n,arguments),n},t.scaleOrdinal=gg,t.scalePoint=function(){return vg(yg.apply(null,arguments).paddingInner(1))},t.scalePow=jg,t.scaleQuantile=function t(){var e,r=[],i=[],o=[];function a(){var t=0,n=Math.max(1,i.length);for(o=new Array(n-1);++t0?o[n-1]:r[0],n=i?[o[i-1],r]:[o[n-1],o[n]]},u.unknown=function(t){return arguments.length?(n=t,u):u},u.thresholds=function(){return o.slice()},u.copy=function(){return t().domain([e,r]).range(a).unknown(n)},hg.apply(Ng(u),arguments)},t.scaleRadial=function t(){var n,e=Sg(),r=[0,1],i=!1;function o(t){var r=function(t){return Math.sign(t)*Math.sqrt(Math.abs(t))}(e(t));return isNaN(r)?n:i?Math.round(r):r}return o.invert=function(t){return e.invert(Hg(t))},o.domain=function(t){return arguments.length?(e.domain(t),o):e.domain()},o.range=function(t){return arguments.length?(e.range((r=Array.from(t,_g)).map(Hg)),o):r.slice()},o.rangeRound=function(t){return o.range(t).round(!0)},o.round=function(t){return arguments.length?(i=!!t,o):i},o.clamp=function(t){return arguments.length?(e.clamp(t),o):e.clamp()},o.unknown=function(t){return arguments.length?(n=t,o):n},o.copy=function(){return t(e.domain(),r).round(i).clamp(e.clamp()).unknown(n)},hg.apply(o,arguments),Ng(o)},t.scaleSequential=function t(){var n=Ng(O_()(mg));return n.copy=function(){return B_(n,t())},dg.apply(n,arguments)},t.scaleSequentialLog=function t(){var n=Fg(O_()).domain([1,10]);return n.copy=function(){return B_(n,t()).base(n.base())},dg.apply(n,arguments)},t.scaleSequentialPow=Y_,t.scaleSequentialQuantile=function t(){var e=[],r=mg;function i(t){if(null!=t&&!isNaN(t=+t))return r((s(e,t,1)-1)/(e.length-1))}return i.domain=function(t){if(!arguments.length)return e.slice();e=[];for(let n of t)null==n||isNaN(n=+n)||e.push(n);return e.sort(n),i},i.interpolator=function(t){return arguments.length?(r=t,i):r},i.range=function(){return e.map(((t,n)=>r(n/(e.length-1))))},i.quantiles=function(t){return Array.from({length:t+1},((n,r)=>at(e,r/t)))},i.copy=function(){return t(r).domain(e)},dg.apply(i,arguments)},t.scaleSequentialSqrt=function(){return Y_.apply(null,arguments).exponent(.5)},t.scaleSequentialSymlog=function t(){var n=Ig(O_());return n.copy=function(){return B_(n,t()).constant(n.constant())},dg.apply(n,arguments)},t.scaleSqrt=function(){return jg.apply(null,arguments).exponent(.5)},t.scaleSymlog=function t(){var n=Ig(Ag());return n.copy=function(){return Tg(n,t()).constant(n.constant())},hg.apply(n,arguments)},t.scaleThreshold=function t(){var n,e=[.5],r=[0,1],i=1;function o(t){return null!=t&&t<=t?r[s(e,t,0,i)]:n}return o.domain=function(t){return arguments.length?(e=Array.from(t),i=Math.min(e.length,r.length-1),o):e.slice()},o.range=function(t){return arguments.length?(r=Array.from(t),i=Math.min(e.length,r.length-1),o):r.slice()},o.invertExtent=function(t){var n=r.indexOf(t);return[e[n-1],e[n]]},o.unknown=function(t){return arguments.length?(n=t,o):n},o.copy=function(){return t().domain(e).range(r).unknown(n)},hg.apply(o,arguments)},t.scaleTime=function(){return hg.apply(I_(uv,cv,tv,Zy,xy,py,sy,ay,iy,t.timeFormat).domain([new Date(2e3,0,1),new Date(2e3,0,2)]),arguments)},t.scaleUtc=function(){return hg.apply(I_(ov,av,ev,Qy,Fy,yy,hy,cy,iy,t.utcFormat).domain([Date.UTC(2e3,0,1),Date.UTC(2e3,0,2)]),arguments)},t.scan=function(t,n){const e=ht(t,n);return e<0?void 0:e},t.schemeAccent=G_,t.schemeBlues=Xb,t.schemeBrBG=ib,t.schemeBuGn=wb,t.schemeBuPu=Tb,t.schemeCategory10=X_,t.schemeDark2=V_,t.schemeGnBu=Sb,t.schemeGreens=Vb,t.schemeGreys=Zb,t.schemeObservable10=W_,t.schemeOrRd=Nb,t.schemeOranges=em,t.schemePRGn=ab,t.schemePaired=Z_,t.schemePastel1=K_,t.schemePastel2=Q_,t.schemePiYG=cb,t.schemePuBu=zb,t.schemePuBuGn=Cb,t.schemePuOr=sb,t.schemePuRd=Db,t.schemePurples=Qb,t.schemeRdBu=hb,t.schemeRdGy=pb,t.schemeRdPu=Fb,t.schemeRdYlBu=yb,t.schemeRdYlGn=_b,t.schemeReds=tm,t.schemeSet1=J_,t.schemeSet2=tb,t.schemeSet3=nb,t.schemeSpectral=mb,t.schemeTableau10=eb,t.schemeYlGn=Ob,t.schemeYlGnBu=Ub,t.schemeYlOrBr=Yb,t.schemeYlOrRd=jb,t.select=Zn,t.selectAll=function(t){return"string"==typeof t?new Vn([document.querySelectorAll(t)],[document.documentElement]):new Vn([Ht(t)],Gn)},t.selection=Wn,t.selector=jt,t.selectorAll=Gt,t.shuffle=dt,t.shuffler=pt,t.some=function(t,n){if("function"!=typeof n)throw new TypeError("test is not a function");let e=-1;for(const r of t)if(n(r,++e,t))return!0;return!1},t.sort=U,t.stack=function(){var t=ym([]),n=dw,e=hw,r=pw;function i(i){var o,a,u=Array.from(t.apply(this,arguments),gw),c=u.length,f=-1;for(const t of i)for(o=0,++f;o0)for(var e,r,i,o,a,u,c=0,f=t[n[0]].length;c0?(r[0]=o,r[1]=o+=i):i<0?(r[1]=a,r[0]=a+=i):(r[0]=0,r[1]=i)},t.stackOffsetExpand=function(t,n){if((r=t.length)>0){for(var e,r,i,o=0,a=t[0].length;o0){for(var e,r=0,i=t[n[0]],o=i.length;r0&&(r=(e=t[n[0]]).length)>0){for(var e,r,i,o=0,a=1;afunction(t){t=`${t}`;let n=t.length;zp(t,n-1)&&!zp(t,n-2)&&(t=t.slice(0,-1));return"/"===t[0]?t:`/${t}`}(t(n,e,r)))),e=n.map(Pp),i=new Set(n).add("");for(const t of e)i.has(t)||(i.add(t),n.push(t),e.push(Pp(t)),h.push(Np));d=(t,e)=>n[e],p=(t,n)=>e[n]}for(a=0,i=h.length;a=0&&(f=h[t]).data===Np;--t)f.data=null}if(u.parent=Sp,u.eachBefore((function(t){t.depth=t.parent.depth+1,--i})).eachBefore(Kd),u.parent=null,i>0)throw new Error("cycle");return u}return r.id=function(t){return arguments.length?(n=Jd(t),r):n},r.parentId=function(t){return arguments.length?(e=Jd(t),r):e},r.path=function(n){return arguments.length?(t=Jd(n),r):t},r},t.style=_n,t.subset=function(t,n){return _t(n,t)},t.sum=function(t,n){let e=0;if(void 0===n)for(let n of t)(n=+n)&&(e+=n);else{let r=-1;for(let i of t)(i=+n(i,++r,t))&&(e+=i)}return e},t.superset=_t,t.svg=Nc,t.symbol=function(t,n){let e=null,r=km(i);function i(){let i;if(e||(e=i=r()),t.apply(this,arguments).draw(e,+n.apply(this,arguments)),i)return e=null,i+""||null}return t="function"==typeof t?t:ym(t||fx),n="function"==typeof n?n:ym(void 0===n?64:+n),i.type=function(n){return arguments.length?(t="function"==typeof n?n:ym(n),i):t},i.size=function(t){return arguments.length?(n="function"==typeof t?t:ym(+t),i):n},i.context=function(t){return arguments.length?(e=null==t?null:t,i):e},i},t.symbolAsterisk=cx,t.symbolCircle=fx,t.symbolCross=sx,t.symbolDiamond=dx,t.symbolDiamond2=px,t.symbolPlus=gx,t.symbolSquare=yx,t.symbolSquare2=vx,t.symbolStar=xx,t.symbolTimes=Px,t.symbolTriangle=Mx,t.symbolTriangle2=Ax,t.symbolWye=Cx,t.symbolX=Px,t.symbols=zx,t.symbolsFill=zx,t.symbolsStroke=$x,t.text=mc,t.thresholdFreedmanDiaconis=function(t,n,e){const r=v(t),i=at(t,.75)-at(t,.25);return r&&i?Math.ceil((e-n)/(2*i*Math.pow(r,-1/3))):1},t.thresholdScott=function(t,n,e){const r=v(t),i=w(t);return r&&i?Math.ceil((e-n)*Math.cbrt(r)/(3.49*i)):1},t.thresholdSturges=K,t.tickFormat=Eg,t.tickIncrement=V,t.tickStep=W,t.ticks=G,t.timeDay=py,t.timeDays=gy,t.timeFormatDefaultLocale=P_,t.timeFormatLocale=hv,t.timeFriday=Sy,t.timeFridays=$y,t.timeHour=sy,t.timeHours=ly,t.timeInterval=Vg,t.timeMillisecond=Wg,t.timeMilliseconds=Zg,t.timeMinute=ay,t.timeMinutes=uy,t.timeMonday=wy,t.timeMondays=ky,t.timeMonth=Zy,t.timeMonths=Ky,t.timeSaturday=Ey,t.timeSaturdays=Dy,t.timeSecond=iy,t.timeSeconds=oy,t.timeSunday=xy,t.timeSundays=Ny,t.timeThursday=Ay,t.timeThursdays=zy,t.timeTickInterval=cv,t.timeTicks=uv,t.timeTuesday=My,t.timeTuesdays=Cy,t.timeWednesday=Ty,t.timeWednesdays=Py,t.timeWeek=xy,t.timeWeeks=Ny,t.timeYear=tv,t.timeYears=nv,t.timeout=$i,t.timer=Ni,t.timerFlush=ki,t.transition=go,t.transpose=gt,t.tree=function(){var t=$p,n=1,e=1,r=null;function i(i){var c=function(t){for(var n,e,r,i,o,a=new Up(t,0),u=[a];n=u.pop();)if(r=n._.children)for(n.children=new Array(o=r.length),i=o-1;i>=0;--i)u.push(e=n.children[i]=new Up(r[i],i)),e.parent=n;return(a.parent=new Up(null,0)).children=[a],a}(i);if(c.eachAfter(o),c.parent.m=-c.z,c.eachBefore(a),r)i.eachBefore(u);else{var f=i,s=i,l=i;i.eachBefore((function(t){t.xs.x&&(s=t),t.depth>l.depth&&(l=t)}));var h=f===s?1:t(f,s)/2,d=h-f.x,p=n/(s.x+h+d),g=e/(l.depth||1);i.eachBefore((function(t){t.x=(t.x+d)*p,t.y=t.depth*g}))}return i}function o(n){var e=n.children,r=n.parent.children,i=n.i?r[n.i-1]:null;if(e){!function(t){for(var n,e=0,r=0,i=t.children,o=i.length;--o>=0;)(n=i[o]).z+=e,n.m+=e,e+=n.s+(r+=n.c)}(n);var o=(e[0].z+e[e.length-1].z)/2;i?(n.z=i.z+t(n._,i._),n.m=n.z-o):n.z=o}else i&&(n.z=i.z+t(n._,i._));n.parent.A=function(n,e,r){if(e){for(var i,o=n,a=n,u=e,c=o.parent.children[0],f=o.m,s=a.m,l=u.m,h=c.m;u=Rp(u),o=Dp(o),u&&o;)c=Dp(c),(a=Rp(a)).a=n,(i=u.z+l-o.z-f+t(u._,o._))>0&&(Fp(qp(u,n,r),n,i),f+=i,s+=i),l+=u.m,f+=o.m,h+=c.m,s+=a.m;u&&!Rp(a)&&(a.t=u,a.m+=l-s),o&&!Dp(c)&&(c.t=o,c.m+=f-h,r=n)}return r}(n,i,n.parent.A||r[0])}function a(t){t._.x=t.z+t.parent.m,t.m+=t.parent.m}function u(t){t.x*=n,t.y=t.depth*e}return i.separation=function(n){return arguments.length?(t=n,i):t},i.size=function(t){return arguments.length?(r=!1,n=+t[0],e=+t[1],i):r?null:[n,e]},i.nodeSize=function(t){return arguments.length?(r=!0,n=+t[0],e=+t[1],i):r?[n,e]:null},i},t.treemap=function(){var t=Yp,n=!1,e=1,r=1,i=[0],o=np,a=np,u=np,c=np,f=np;function s(t){return t.x0=t.y0=0,t.x1=e,t.y1=r,t.eachBefore(l),i=[0],n&&t.eachBefore(Tp),t}function l(n){var e=i[n.depth],r=n.x0+e,s=n.y0+e,l=n.x1-e,h=n.y1-e;l=e-1){var s=u[n];return s.x0=i,s.y0=o,s.x1=a,void(s.y1=c)}var l=f[n],h=r/2+l,d=n+1,p=e-1;for(;d>>1;f[g]c-o){var _=r?(i*v+a*y)/r:a;t(n,d,y,i,o,_,c),t(d,e,v,_,o,a,c)}else{var b=r?(o*v+c*y)/r:c;t(n,d,y,i,o,a,b),t(d,e,v,i,b,a,c)}}(0,c,t.value,n,e,r,i)},t.treemapDice=Ap,t.treemapResquarify=Lp,t.treemapSlice=Ip,t.treemapSliceDice=function(t,n,e,r,i){(1&t.depth?Ip:Ap)(t,n,e,r,i)},t.treemapSquarify=Yp,t.tsv=Mc,t.tsvFormat=lc,t.tsvFormatBody=hc,t.tsvFormatRow=pc,t.tsvFormatRows=dc,t.tsvFormatValue=gc,t.tsvParse=fc,t.tsvParseRows=sc,t.union=function(...t){const n=new InternSet;for(const e of t)for(const t of e)n.add(t);return n},t.unixDay=_y,t.unixDays=by,t.utcDay=yy,t.utcDays=vy,t.utcFriday=By,t.utcFridays=Vy,t.utcHour=hy,t.utcHours=dy,t.utcMillisecond=Wg,t.utcMilliseconds=Zg,t.utcMinute=cy,t.utcMinutes=fy,t.utcMonday=qy,t.utcMondays=jy,t.utcMonth=Qy,t.utcMonths=Jy,t.utcSaturday=Yy,t.utcSaturdays=Wy,t.utcSecond=iy,t.utcSeconds=oy,t.utcSunday=Fy,t.utcSundays=Ly,t.utcThursday=Oy,t.utcThursdays=Gy,t.utcTickInterval=av,t.utcTicks=ov,t.utcTuesday=Uy,t.utcTuesdays=Hy,t.utcWednesday=Iy,t.utcWednesdays=Xy,t.utcWeek=Fy,t.utcWeeks=Ly,t.utcYear=ev,t.utcYears=rv,t.variance=x,t.version="7.9.0",t.window=pn,t.xml=Sc,t.zip=function(){return gt(arguments)},t.zoom=function(){var t,n,e,r=Ew,i=Nw,o=zw,a=Cw,u=Pw,c=[0,1/0],f=[[-1/0,-1/0],[1/0,1/0]],s=250,l=ri,h=$t("start","zoom","end"),d=500,p=150,g=0,y=10;function v(t){t.property("__zoom",kw).on("wheel.zoom",T,{passive:!1}).on("mousedown.zoom",A).on("dblclick.zoom",S).filter(u).on("touchstart.zoom",E).on("touchmove.zoom",N).on("touchend.zoom touchcancel.zoom",k).style("-webkit-tap-highlight-color","rgba(0,0,0,0)")}function _(t,n){return(n=Math.max(c[0],Math.min(c[1],n)))===t.k?t:new ww(n,t.x,t.y)}function b(t,n,e){var r=n[0]-e[0]*t.k,i=n[1]-e[1]*t.k;return r===t.x&&i===t.y?t:new ww(t.k,r,i)}function m(t){return[(+t[0][0]+ +t[1][0])/2,(+t[0][1]+ +t[1][1])/2]}function x(t,n,e,r){t.on("start.zoom",(function(){w(this,arguments).event(r).start()})).on("interrupt.zoom end.zoom",(function(){w(this,arguments).event(r).end()})).tween("zoom",(function(){var t=this,o=arguments,a=w(t,o).event(r),u=i.apply(t,o),c=null==e?m(u):"function"==typeof e?e.apply(t,o):e,f=Math.max(u[1][0]-u[0][0],u[1][1]-u[0][1]),s=t.__zoom,h="function"==typeof n?n.apply(t,o):n,d=l(s.invert(c).concat(f/s.k),h.invert(c).concat(f/h.k));return function(t){if(1===t)t=h;else{var n=d(t),e=f/n[2];t=new ww(e,c[0]-n[0]*e,c[1]-n[1]*e)}a.zoom(null,t)}}))}function w(t,n,e){return!e&&t.__zooming||new M(t,n)}function M(t,n){this.that=t,this.args=n,this.active=0,this.sourceEvent=null,this.extent=i.apply(t,n),this.taps=0}function T(t,...n){if(r.apply(this,arguments)){var e=w(this,n).event(t),i=this.__zoom,u=Math.max(c[0],Math.min(c[1],i.k*Math.pow(2,a.apply(this,arguments)))),s=ne(t);if(e.wheel)e.mouse[0][0]===s[0]&&e.mouse[0][1]===s[1]||(e.mouse[1]=i.invert(e.mouse[0]=s)),clearTimeout(e.wheel);else{if(i.k===u)return;e.mouse=[s,i.invert(s)],Gi(this),e.start()}Sw(t),e.wheel=setTimeout((function(){e.wheel=null,e.end()}),p),e.zoom("mouse",o(b(_(i,u),e.mouse[0],e.mouse[1]),e.extent,f))}}function A(t,...n){if(!e&&r.apply(this,arguments)){var i=t.currentTarget,a=w(this,n,!0).event(t),u=Zn(t.view).on("mousemove.zoom",(function(t){if(Sw(t),!a.moved){var n=t.clientX-s,e=t.clientY-l;a.moved=n*n+e*e>g}a.event(t).zoom("mouse",o(b(a.that.__zoom,a.mouse[0]=ne(t,i),a.mouse[1]),a.extent,f))}),!0).on("mouseup.zoom",(function(t){u.on("mousemove.zoom mouseup.zoom",null),ue(t.view,a.moved),Sw(t),a.event(t).end()}),!0),c=ne(t,i),s=t.clientX,l=t.clientY;ae(t.view),Aw(t),a.mouse=[c,this.__zoom.invert(c)],Gi(this),a.start()}}function S(t,...n){if(r.apply(this,arguments)){var e=this.__zoom,a=ne(t.changedTouches?t.changedTouches[0]:t,this),u=e.invert(a),c=e.k*(t.shiftKey?.5:2),l=o(b(_(e,c),a,u),i.apply(this,n),f);Sw(t),s>0?Zn(this).transition().duration(s).call(x,l,a,t):Zn(this).call(v.transform,l,a,t)}}function E(e,...i){if(r.apply(this,arguments)){var o,a,u,c,f=e.touches,s=f.length,l=w(this,i,e.changedTouches.length===s).event(e);for(Aw(e),a=0;a0&&s(a.width)/e.offsetWidth||1,p=e.offsetHeight>0&&s(a.height)/e.offsetHeight||1);var u=(n(e)?t(e):window).visualViewport,l=!c()&&i,d=(a.left+(l&&u?u.offsetLeft:0))/f,h=(a.top+(l&&u?u.offsetTop:0))/p,m=a.width/f,v=a.height/p;return{width:m,height:v,top:h,right:d+m,bottom:h+v,left:d,x:d,y:h}}function u(e){var n=t(e);return{scrollLeft:n.pageXOffset,scrollTop:n.pageYOffset}}function l(e){return e?(e.nodeName||"").toLowerCase():null}function d(e){return((n(e)?e.ownerDocument:e.document)||window.document).documentElement}function h(e){return p(d(e)).left+u(e).scrollLeft}function m(e){return t(e).getComputedStyle(e)}function v(e){var t=m(e),n=t.overflow,r=t.overflowX,o=t.overflowY;return/auto|scroll|overlay|hidden/.test(n+o+r)}function y(e,n,o){void 0===o&&(o=!1);var i,a,f=r(n),c=r(n)&&function(e){var t=e.getBoundingClientRect(),n=s(t.width)/e.offsetWidth||1,r=s(t.height)/e.offsetHeight||1;return 1!==n||1!==r}(n),m=d(n),y=p(e,c,o),g={scrollLeft:0,scrollTop:0},b={x:0,y:0};return(f||!f&&!o)&&(("body"!==l(n)||v(m))&&(g=(i=n)!==t(i)&&r(i)?{scrollLeft:(a=i).scrollLeft,scrollTop:a.scrollTop}:u(i)),r(n)?((b=p(n,!0)).x+=n.clientLeft,b.y+=n.clientTop):m&&(b.x=h(m))),{x:y.left+g.scrollLeft-b.x,y:y.top+g.scrollTop-b.y,width:y.width,height:y.height}}function g(e){var t=p(e),n=e.offsetWidth,r=e.offsetHeight;return Math.abs(t.width-n)<=1&&(n=t.width),Math.abs(t.height-r)<=1&&(r=t.height),{x:e.offsetLeft,y:e.offsetTop,width:n,height:r}}function b(e){return"html"===l(e)?e:e.assignedSlot||e.parentNode||(o(e)?e.host:null)||d(e)}function x(e){return["html","body","#document"].indexOf(l(e))>=0?e.ownerDocument.body:r(e)&&v(e)?e:x(b(e))}function w(e,n){var r;void 0===n&&(n=[]);var o=x(e),i=o===(null==(r=e.ownerDocument)?void 0:r.body),a=t(o),s=i?[a].concat(a.visualViewport||[],v(o)?o:[]):o,f=n.concat(s);return i?f:f.concat(w(b(s)))}function O(e){return["table","td","th"].indexOf(l(e))>=0}function j(e){return r(e)&&"fixed"!==m(e).position?e.offsetParent:null}function E(e){for(var n=t(e),i=j(e);i&&O(i)&&"static"===m(i).position;)i=j(i);return i&&("html"===l(i)||"body"===l(i)&&"static"===m(i).position)?n:i||function(e){var t=/firefox/i.test(f());if(/Trident/i.test(f())&&r(e)&&"fixed"===m(e).position)return null;var n=b(e);for(o(n)&&(n=n.host);r(n)&&["html","body"].indexOf(l(n))<0;){var i=m(n);if("none"!==i.transform||"none"!==i.perspective||"paint"===i.contain||-1!==["transform","perspective"].indexOf(i.willChange)||t&&"filter"===i.willChange||t&&i.filter&&"none"!==i.filter)return n;n=n.parentNode}return null}(e)||n}var D="top",A="bottom",L="right",P="left",M="auto",k=[D,A,L,P],W="start",B="end",H="viewport",T="popper",R=k.reduce((function(e,t){return e.concat([t+"-"+W,t+"-"+B])}),[]),S=[].concat(k,[M]).reduce((function(e,t){return e.concat([t,t+"-"+W,t+"-"+B])}),[]),V=["beforeRead","read","afterRead","beforeMain","main","afterMain","beforeWrite","write","afterWrite"];function q(e){var t=new Map,n=new Set,r=[];function o(e){n.add(e.name),[].concat(e.requires||[],e.requiresIfExists||[]).forEach((function(e){if(!n.has(e)){var r=t.get(e);r&&o(r)}})),r.push(e)}return e.forEach((function(e){t.set(e.name,e)})),e.forEach((function(e){n.has(e.name)||o(e)})),r}function C(e,t){var n=t.getRootNode&&t.getRootNode();if(e.contains(t))return!0;if(n&&o(n)){var r=t;do{if(r&&e.isSameNode(r))return!0;r=r.parentNode||r.host}while(r)}return!1}function N(e){return Object.assign({},e,{left:e.x,top:e.y,right:e.x+e.width,bottom:e.y+e.height})}function I(e,r,o){return r===H?N(function(e,n){var r=t(e),o=d(e),i=r.visualViewport,a=o.clientWidth,s=o.clientHeight,f=0,p=0;if(i){a=i.width,s=i.height;var u=c();(u||!u&&"fixed"===n)&&(f=i.offsetLeft,p=i.offsetTop)}return{width:a,height:s,x:f+h(e),y:p}}(e,o)):n(r)?function(e,t){var n=p(e,!1,"fixed"===t);return n.top=n.top+e.clientTop,n.left=n.left+e.clientLeft,n.bottom=n.top+e.clientHeight,n.right=n.left+e.clientWidth,n.width=e.clientWidth,n.height=e.clientHeight,n.x=n.left,n.y=n.top,n}(r,o):N(function(e){var t,n=d(e),r=u(e),o=null==(t=e.ownerDocument)?void 0:t.body,a=i(n.scrollWidth,n.clientWidth,o?o.scrollWidth:0,o?o.clientWidth:0),s=i(n.scrollHeight,n.clientHeight,o?o.scrollHeight:0,o?o.clientHeight:0),f=-r.scrollLeft+h(e),c=-r.scrollTop;return"rtl"===m(o||n).direction&&(f+=i(n.clientWidth,o?o.clientWidth:0)-a),{width:a,height:s,x:f,y:c}}(d(e)))}function _(e,t,o,s){var f="clippingParents"===t?function(e){var t=w(b(e)),o=["absolute","fixed"].indexOf(m(e).position)>=0&&r(e)?E(e):e;return n(o)?t.filter((function(e){return n(e)&&C(e,o)&&"body"!==l(e)})):[]}(e):[].concat(t),c=[].concat(f,[o]),p=c[0],u=c.reduce((function(t,n){var r=I(e,n,s);return t.top=i(r.top,t.top),t.right=a(r.right,t.right),t.bottom=a(r.bottom,t.bottom),t.left=i(r.left,t.left),t}),I(e,p,s));return u.width=u.right-u.left,u.height=u.bottom-u.top,u.x=u.left,u.y=u.top,u}function F(e){return e.split("-")[0]}function U(e){return e.split("-")[1]}function z(e){return["top","bottom"].indexOf(e)>=0?"x":"y"}function X(e){var t,n=e.reference,r=e.element,o=e.placement,i=o?F(o):null,a=o?U(o):null,s=n.x+n.width/2-r.width/2,f=n.y+n.height/2-r.height/2;switch(i){case D:t={x:s,y:n.y-r.height};break;case A:t={x:s,y:n.y+n.height};break;case L:t={x:n.x+n.width,y:f};break;case P:t={x:n.x-r.width,y:f};break;default:t={x:n.x,y:n.y}}var c=i?z(i):null;if(null!=c){var p="y"===c?"height":"width";switch(a){case W:t[c]=t[c]-(n[p]/2-r[p]/2);break;case B:t[c]=t[c]+(n[p]/2-r[p]/2)}}return t}function Y(e){return Object.assign({},{top:0,right:0,bottom:0,left:0},e)}function G(e,t){return t.reduce((function(t,n){return t[n]=e,t}),{})}function J(e,t){void 0===t&&(t={});var r=t,o=r.placement,i=void 0===o?e.placement:o,a=r.strategy,s=void 0===a?e.strategy:a,f=r.boundary,c=void 0===f?"clippingParents":f,u=r.rootBoundary,l=void 0===u?H:u,h=r.elementContext,m=void 0===h?T:h,v=r.altBoundary,y=void 0!==v&&v,g=r.padding,b=void 0===g?0:g,x=Y("number"!=typeof b?b:G(b,k)),w=m===T?"reference":T,O=e.rects.popper,j=e.elements[y?w:m],E=_(n(j)?j:j.contextElement||d(e.elements.popper),c,l,s),P=p(e.elements.reference),M=X({reference:P,element:O,strategy:"absolute",placement:i}),W=N(Object.assign({},O,M)),B=m===T?W:P,R={top:E.top-B.top+x.top,bottom:B.bottom-E.bottom+x.bottom,left:E.left-B.left+x.left,right:B.right-E.right+x.right},S=e.modifiersData.offset;if(m===T&&S){var V=S[i];Object.keys(R).forEach((function(e){var t=[L,A].indexOf(e)>=0?1:-1,n=[D,A].indexOf(e)>=0?"y":"x";R[e]+=V[n]*t}))}return R}var K={placement:"bottom",modifiers:[],strategy:"absolute"};function Q(){for(var e=arguments.length,t=new Array(e),n=0;n=0?-1:1,i="function"==typeof n?n(Object.assign({},t,{placement:e})):n,a=i[0],s=i[1];return a=a||0,s=(s||0)*o,[P,L].indexOf(r)>=0?{x:s,y:a}:{x:a,y:s}}(n,t.rects,i),e}),{}),s=a[t.placement],f=s.x,c=s.y;null!=t.modifiersData.popperOffsets&&(t.modifiersData.popperOffsets.x+=f,t.modifiersData.popperOffsets.y+=c),t.modifiersData[r]=a}},se={left:"right",right:"left",bottom:"top",top:"bottom"};function fe(e){return e.replace(/left|right|bottom|top/g,(function(e){return se[e]}))}var ce={start:"end",end:"start"};function pe(e){return e.replace(/start|end/g,(function(e){return ce[e]}))}function ue(e,t){void 0===t&&(t={});var n=t,r=n.placement,o=n.boundary,i=n.rootBoundary,a=n.padding,s=n.flipVariations,f=n.allowedAutoPlacements,c=void 0===f?S:f,p=U(r),u=p?s?R:R.filter((function(e){return U(e)===p})):k,l=u.filter((function(e){return c.indexOf(e)>=0}));0===l.length&&(l=u);var d=l.reduce((function(t,n){return t[n]=J(e,{placement:n,boundary:o,rootBoundary:i,padding:a})[F(n)],t}),{});return Object.keys(d).sort((function(e,t){return d[e]-d[t]}))}var le={name:"flip",enabled:!0,phase:"main",fn:function(e){var t=e.state,n=e.options,r=e.name;if(!t.modifiersData[r]._skip){for(var o=n.mainAxis,i=void 0===o||o,a=n.altAxis,s=void 0===a||a,f=n.fallbackPlacements,c=n.padding,p=n.boundary,u=n.rootBoundary,l=n.altBoundary,d=n.flipVariations,h=void 0===d||d,m=n.allowedAutoPlacements,v=t.options.placement,y=F(v),g=f||(y===v||!h?[fe(v)]:function(e){if(F(e)===M)return[];var t=fe(e);return[pe(e),t,pe(t)]}(v)),b=[v].concat(g).reduce((function(e,n){return e.concat(F(n)===M?ue(t,{placement:n,boundary:p,rootBoundary:u,padding:c,flipVariations:h,allowedAutoPlacements:m}):n)}),[]),x=t.rects.reference,w=t.rects.popper,O=new Map,j=!0,E=b[0],k=0;k=0,S=R?"width":"height",V=J(t,{placement:B,boundary:p,rootBoundary:u,altBoundary:l,padding:c}),q=R?T?L:P:T?A:D;x[S]>w[S]&&(q=fe(q));var C=fe(q),N=[];if(i&&N.push(V[H]<=0),s&&N.push(V[q]<=0,V[C]<=0),N.every((function(e){return e}))){E=B,j=!1;break}O.set(B,N)}if(j)for(var I=function(e){var t=b.find((function(t){var n=O.get(t);if(n)return n.slice(0,e).every((function(e){return e}))}));if(t)return E=t,"break"},_=h?3:1;_>0;_--){if("break"===I(_))break}t.placement!==E&&(t.modifiersData[r]._skip=!0,t.placement=E,t.reset=!0)}},requiresIfExists:["offset"],data:{_skip:!1}};function de(e,t,n){return i(e,a(t,n))}var he={name:"preventOverflow",enabled:!0,phase:"main",fn:function(e){var t=e.state,n=e.options,r=e.name,o=n.mainAxis,s=void 0===o||o,f=n.altAxis,c=void 0!==f&&f,p=n.boundary,u=n.rootBoundary,l=n.altBoundary,d=n.padding,h=n.tether,m=void 0===h||h,v=n.tetherOffset,y=void 0===v?0:v,b=J(t,{boundary:p,rootBoundary:u,padding:d,altBoundary:l}),x=F(t.placement),w=U(t.placement),O=!w,j=z(x),M="x"===j?"y":"x",k=t.modifiersData.popperOffsets,B=t.rects.reference,H=t.rects.popper,T="function"==typeof y?y(Object.assign({},t.rects,{placement:t.placement})):y,R="number"==typeof T?{mainAxis:T,altAxis:T}:Object.assign({mainAxis:0,altAxis:0},T),S=t.modifiersData.offset?t.modifiersData.offset[t.placement]:null,V={x:0,y:0};if(k){if(s){var q,C="y"===j?D:P,N="y"===j?A:L,I="y"===j?"height":"width",_=k[j],X=_+b[C],Y=_-b[N],G=m?-H[I]/2:0,K=w===W?B[I]:H[I],Q=w===W?-H[I]:-B[I],Z=t.elements.arrow,$=m&&Z?g(Z):{width:0,height:0},ee=t.modifiersData["arrow#persistent"]?t.modifiersData["arrow#persistent"].padding:{top:0,right:0,bottom:0,left:0},te=ee[C],ne=ee[N],re=de(0,B[I],$[I]),oe=O?B[I]/2-G-re-te-R.mainAxis:K-re-te-R.mainAxis,ie=O?-B[I]/2+G+re+ne+R.mainAxis:Q+re+ne+R.mainAxis,ae=t.elements.arrow&&E(t.elements.arrow),se=ae?"y"===j?ae.clientTop||0:ae.clientLeft||0:0,fe=null!=(q=null==S?void 0:S[j])?q:0,ce=_+ie-fe,pe=de(m?a(X,_+oe-fe-se):X,_,m?i(Y,ce):Y);k[j]=pe,V[j]=pe-_}if(c){var ue,le="x"===j?D:P,he="x"===j?A:L,me=k[M],ve="y"===M?"height":"width",ye=me+b[le],ge=me-b[he],be=-1!==[D,P].indexOf(x),xe=null!=(ue=null==S?void 0:S[M])?ue:0,we=be?ye:me-B[ve]-H[ve]-xe+R.altAxis,Oe=be?me+B[ve]+H[ve]-xe-R.altAxis:ge,je=m&&be?function(e,t,n){var r=de(e,t,n);return r>n?n:r}(we,me,Oe):de(m?we:ye,me,m?Oe:ge);k[M]=je,V[M]=je-me}t.modifiersData[r]=V}},requiresIfExists:["offset"]};var me={name:"arrow",enabled:!0,phase:"main",fn:function(e){var t,n=e.state,r=e.name,o=e.options,i=n.elements.arrow,a=n.modifiersData.popperOffsets,s=F(n.placement),f=z(s),c=[P,L].indexOf(s)>=0?"height":"width";if(i&&a){var p=function(e,t){return Y("number"!=typeof(e="function"==typeof e?e(Object.assign({},t.rects,{placement:t.placement})):e)?e:G(e,k))}(o.padding,n),u=g(i),l="y"===f?D:P,d="y"===f?A:L,h=n.rects.reference[c]+n.rects.reference[f]-a[f]-n.rects.popper[c],m=a[f]-n.rects.reference[f],v=E(i),y=v?"y"===f?v.clientHeight||0:v.clientWidth||0:0,b=h/2-m/2,x=p[l],w=y-u[c]-p[d],O=y/2-u[c]/2+b,j=de(x,O,w),M=f;n.modifiersData[r]=((t={})[M]=j,t.centerOffset=j-O,t)}},effect:function(e){var t=e.state,n=e.options.element,r=void 0===n?"[data-popper-arrow]":n;null!=r&&("string"!=typeof r||(r=t.elements.popper.querySelector(r)))&&C(t.elements.popper,r)&&(t.elements.arrow=r)},requires:["popperOffsets"],requiresIfExists:["preventOverflow"]};function ve(e,t,n){return void 0===n&&(n={x:0,y:0}),{top:e.top-t.height-n.y,right:e.right-t.width+n.x,bottom:e.bottom-t.height+n.y,left:e.left-t.width-n.x}}function ye(e){return[D,L,A,P].some((function(t){return e[t]>=0}))}var ge={name:"hide",enabled:!0,phase:"main",requiresIfExists:["preventOverflow"],fn:function(e){var t=e.state,n=e.name,r=t.rects.reference,o=t.rects.popper,i=t.modifiersData.preventOverflow,a=J(t,{elementContext:"reference"}),s=J(t,{altBoundary:!0}),f=ve(a,r),c=ve(s,o,i),p=ye(f),u=ye(c);t.modifiersData[n]={referenceClippingOffsets:f,popperEscapeOffsets:c,isReferenceHidden:p,hasPopperEscaped:u},t.attributes.popper=Object.assign({},t.attributes.popper,{"data-popper-reference-hidden":p,"data-popper-escaped":u})}},be=Z({defaultModifiers:[ee,te,oe,ie]}),xe=[ee,te,oe,ie,ae,le,he,me,ge],we=Z({defaultModifiers:xe});e.applyStyles=ie,e.arrow=me,e.computeStyles=oe,e.createPopper=we,e.createPopperLite=be,e.defaultModifiers=xe,e.detectOverflow=J,e.eventListeners=ee,e.flip=le,e.hide=ge,e.offset=ae,e.popperGenerator=Z,e.popperOffsets=te,e.preventOverflow=he,Object.defineProperty(e,"__esModule",{value:!0})})); +//# sourceMappingURL=popper.min.js.map diff --git a/src/agenda_culturel/static/style.scss b/src/agenda_culturel/static/style.scss index b155257..e30d38c 100644 --- a/src/agenda_culturel/static/style.scss +++ b/src/agenda_culturel/static/style.scss @@ -1906,3 +1906,7 @@ dialog { .single-event header .buttons [role="button"] { font-size: 90%; } + +#cal-heatmap-startday g { + cursor: pointer; +} diff --git a/src/agenda_culturel/templates/agenda_culturel/page.html b/src/agenda_culturel/templates/agenda_culturel/page.html index c934916..81d2750 100644 --- a/src/agenda_culturel/templates/agenda_culturel/page.html +++ b/src/agenda_culturel/templates/agenda_culturel/page.html @@ -112,26 +112,18 @@